SalutefaceAAC/api-error-resolution-pairs

API Error Resolution Pairs

A synthetic dataset of real-world API error scenarios paired with explanations and fixes. Each example captures a broken code snippet, the error it produces, a plain-English explanation of the root cause, a corrected implementation, and a distilled key insight.

Dataset Summary

Split	Examples
train	132
validation	16
test	16
Total	164

Quick Start

Load the dataset

from datasets import load_dataset

ds = load_dataset("SalutefaceAAC/api-error-resolution-pairs")
print(ds)
# DatasetDict({
#     train: Dataset({features: [...], num_rows: 132}),
#     validation: Dataset({features: [...], num_rows: 16}),
#     test: Dataset({features: [...], num_rows: 16})
# })

# Inspect a record
example = ds["train"][0]
print(example["error_type"])     # e.g. "timeout_missing"
print(example["broken_code"])    # code that triggers the error
print(example["fixed_code"])     # corrected implementation
print(example["key_insight"])    # one-sentence principle

Filter by language or error type

# All Python examples
py_examples = ds["train"].filter(lambda x: x["language"] == "python")

# Rate-limiting errors only
rate_limit = ds["train"].filter(lambda x: x["error_type"] == "rate_limit")

# Multi-filter: TypeScript + auth errors
ts_auth = ds["train"].filter(
    lambda x: x["language"] == "typescript" and "auth" in x["error_type"]
)

RAG retrieval (semantic search over error patterns)

from sentence_transformers import SentenceTransformer
import numpy as np

model = SentenceTransformer("all-MiniLM-L6-v2")

train = ds["train"]
# Embed error messages as the retrieval key
embeddings = model.encode(train["error_message"], show_progress_bar=True)

def find_similar(query: str, top_k: int = 3):
    q_emb = model.encode([query])
    scores = np.dot(embeddings, q_emb.T).squeeze()
    top_idx = np.argsort(scores)[::-1][:top_k]
    for i in top_idx:
        print(f"[{scores[i]:.3f}] {train[int(i)]['error_type']} — {train[int(i)]['key_insight']}")

find_similar("Connection refused when calling external API")

Fine-tuning prompt template

def format_for_finetuning(example):
    """Format a record as an instruction-following prompt."""
    prompt = (
        f"Language: {example['language']}\n"
        f"Library: {example['library']}\n"
        f"Error: {example['error_message']}\n\n"
        f"Broken code:\n```\n{example['broken_code']}\n```\n\n"
        "Explain the root cause and provide the corrected implementation."
    )
    completion = (
        f"Root cause: {example['explanation']}\n\n"
        f"Fixed code:\n```\n{example['fixed_code']}\n```\n\n"
        f"Key insight: {example['key_insight']}"
    )
    return {"prompt": prompt, "completion": completion}

formatted = ds["train"].map(format_for_finetuning)

Sample Records

Example 1 — Python / requests: Large file download (MemoryError)

Field	Value
language	python
library	requests
error_type	stream_large_response
error_message	MemoryError downloading large file

Broken code:

resp = requests.get("https://example.com/large-file.zip")
with open("large-file.zip", "wb") as f:
    f.write(resp.content)

Fixed code:

resp = requests.get("https://example.com/large-file.zip", stream=True)
with open("large-file.zip", "wb") as f:
    for chunk in resp.iter_content(chunk_size=8192):
        f.write(chunk)

Key insight: Use stream=True and iter_content() to download large files without loading them into memory.

---

Example 2 — JavaScript / axios: Unhandled cancellation

Field	Value
language	javascript
library	axios
error_type	cancel_request
error_message	CanceledError unhandled when navigating away

Broken code:

const source = axios.CancelToken.source();
axios.get("/slow-api", { cancelToken: source.token });
source.cancel();

Fixed code:

const controller = new AbortController();
try {
    const resp = await axios.get("/slow-api", { signal: controller.signal });
    process(resp.data);
} catch (err) {
    if (!axios.isCancel(err)) throw err;
}
// to cancel: controller.abort();

Key insight: Use AbortController with axios (v1+) and filter cancellations with axios.isCancel(err).

---

Example 3 — REST: Content negotiation failure

Field	Value
language	rest
library	generic
error_type	content_negotiation
error_message	406 Not Acceptable

Broken request:

GET /api/data
Accept: text/html

Fixed request:

GET /api/data
Accept: application/json

Key insight: Match the Accept header to the media types the server advertises.

Schema

Field	Type	Description
id	int	Unique record identifier
language	string	Programming language (python, javascript, typescript, go, java, rest)
library	string	Library or framework (requests, httpx, boto3, openai, anthropic, fetch, axios, okhttp, net/http, …)
error_type	string	Short error category slug
error_message	string	The actual error message or symptom
broken_code	string	Snippet that triggers the error
explanation	string	Root cause explanation
fixed_code	string	Corrected implementation
key_insight	string	One-sentence principle to prevent this class of error
tags	string	Comma-separated tag list

Coverage

Languages & Libraries

Language	Libraries
Python	requests, httpx, boto3, openai, anthropic, aiohttp, grpc, gql, stripe, google-auth, redis
JavaScript	fetch, axios
TypeScript	openai, react-query
Go	net/http
Java	okhttp
REST	Generic HTTP patterns

Error Categories

• Auth: missing/malformed credentials, 401 flows
• Timeout: missing timeouts, context deadlines
• JSON body: wrong encoding, missing Content-Type
• Error handling: unchecked 4xx/5xx, silent failures
• Rate limiting: 429, Retry-After, backoff
• Pagination: offset vs cursor, last-page edge cases
• Resource leaks: unclosed bodies, sessions, connections
• SSL/TLS: certificate verification, insecure channels
• Performance: connection pools, pipelines, parallel requests
• Streaming: async iteration, chunk handling
• Function/tool calling: history management, tool result format
• Structured output: JSON mode, Zod schemas
• Idempotency: duplicate charges, retry safety
• Versioning: breaking changes, additive vs destructive

Generation Methodology

Records were hand-authored one at a time, each capturing a distinct error pattern from real developer experience. A parametric augmentation layer generates variants across different API endpoints, token formats, and timeout values to increase dataset breadth without noise. All records passed MD5-based deduplication (keyed on broken_code + fixed_code).

No model was used to generate records. All broken_code / fixed_code / explanation / key_insight values were written manually.

Intended Uses

• Fine-tuning code LLMs on error diagnosis and remediation
• Retrieval-augmented code assistance (RAG over error patterns)
• Benchmark evaluation for debugging models
• Developer education tooling

Limitations

• Augmentation depth: parametric augmentation varies endpoints and timeout values only — augmented records share structure with their base and increase breadth but not conceptual depth.
• Language coverage: Java examples focus on Android context (OkHttp); server-side Java (Spring, Quarkus) patterns are underrepresented. Go examples cover net/http only.
• Scenario complexity: each record is a single-error / single-fix scenario. Multi-step debugging chains and cascading failures are out of scope.
• Domain scope: covers mainstream REST and gRPC clients; WebSocket, GraphQL subscriptions, and binary protocols are not included.
• No runtime validation: code snippets are validated by human review, not executed; edge-case compilation issues may exist.

License

Apache 2.0

Citation

@dataset{saluteface_api_error_resolution_2026,
  title  = {API Error Resolution Pairs},
  author = {SalutefaceAAC},
  year   = {2026},
  url    = {https://huggingface.co/datasets/SalutefaceAAC/api-error-resolution-pairs}
}