---
language:
  - en
license: apache-2.0
task_categories:
  - text-generation
tags:
  - api
  - debugging
  - error-resolution
  - code
  - synthetic
  - python
  - javascript
  - typescript
  - go
  - java
  - rest
pretty_name: API Error Resolution Pairs
size_categories:
  - n<1K
dataset_info:
  features:
    - name: id
      dtype: int64
    - name: language
      dtype: string
    - name: library
      dtype: string
    - name: error_type
      dtype: string
    - name: error_message
      dtype: string
    - name: broken_code
      dtype: string
    - name: explanation
      dtype: string
    - name: fixed_code
      dtype: string
    - name: key_insight
      dtype: string
    - name: tags
      dtype: string
  splits:
    - name: train
      num_examples: 132
    - name: validation
      num_examples: 16
    - name: test
      num_examples: 16
---

# 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

```python
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

```python
# 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)

```python
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

```python
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:**
```python
resp = requests.get("https://example.com/large-file.zip")
with open("large-file.zip", "wb") as f:
    f.write(resp.content)
```

**Fixed code:**
```python
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:**
```javascript
const source = axios.CancelToken.source();
axios.get("/slow-api", { cancelToken: source.token });
source.cancel();
```

**Fixed code:**
```javascript
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:**
```http
GET /api/data
Accept: text/html
```

**Fixed request:**
```http
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

```bibtex
@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}
}
```