# Error Handler

> Provides battle-tested error handling patterns for TypeScript and Python. Use when implementing error handling, creating try/catch blocks, or handling exceptions.

- **Type:** Skill
- **Install:** `agentstack add skill-benshapyro-cadre-devkit-claude-error-handler`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [benshapyro](https://agentstack.voostack.com/s/benshapyro)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [benshapyro](https://github.com/benshapyro)
- **Source:** https://github.com/benshapyro/cadre-devkit-claude/tree/main/skills/error-handler

## Install

```sh
agentstack add skill-benshapyro-cadre-devkit-claude-error-handler
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Error Handler Skill

Implements robust error handling patterns that provide meaningful errors, graceful degradation, and proper logging.

## Resources

For detailed code examples, see:
- `references/typescript-patterns.md` - TypeScript/JavaScript patterns (Express, React)
- `references/python-patterns.md` - Python patterns (FastAPI, Flask)

## Core Principles

1. **Fail Fast, Fail Loudly** - Catch errors early, make them visible
2. **Context is King** - Include relevant information in error messages
3. **Never Swallow Errors** - Always log, re-throw, or handle explicitly
4. **User-Friendly Messages** - Show generic messages to users, log details server-side
5. **Typed Errors** - Use custom error classes for different failure types

## Quick Patterns

### Custom Error Class (TypeScript)

```typescript
export class AppError extends Error {
  constructor(
    message: string,
    public code: string,
    public statusCode: number = 500,
    public context?: Record
  ) {
    super(message);
    this.name = this.constructor.name;
  }
}

// Specific types
export class ValidationError extends AppError {
  constructor(message: string, context?: Record) {
    super(message, 'VALIDATION_ERROR', 400, context);
  }
}

export class NotFoundError extends AppError {
  constructor(resource: string, id: string) {
    super(`${resource} not found`, 'NOT_FOUND', 404, { resource, id });
  }
}
```

### Custom Exception (Python)

```python
class AppError(Exception):
    def __init__(self, message: str, code: str, status_code: int = 500, context: dict | None = None):
        super().__init__(message)
        self.message = message
        self.code = code
        self.status_code = status_code
        self.context = context or {}

class ValidationError(AppError):
    def __init__(self, message: str, context: dict | None = None):
        super().__init__(message, "VALIDATION_ERROR", 400, context)
```

### Error Handling Pattern

```typescript
async function fetchData(id: string): Promise {
  if (!id) throw new ValidationError('Invalid ID', { id });

  try {
    const data = await db.find(id);
    if (!data) throw new NotFoundError('Data', id);
    return data;
  } catch (error) {
    if (error instanceof AppError) throw error;
    throw new DatabaseError('Fetch failed', { id, originalError: error.message });
  }
}
```

## Best Practices

### DO

- Use custom error classes for different error types
- Include context in errors (but sanitize before sending to client)
- Log errors with structured data (method, path, user ID, etc.)
- Provide user-friendly error messages
- Handle errors at appropriate levels (function, route, global)
- Always clean up resources (use try/finally or context managers)
- Add retry logic for transient failures
- Test error paths (negative tests)

### DON'T

- Swallow errors silently (`catch (e) {}`)
- Leak sensitive information in error messages
- Use generic error messages without context
- Ignore promise rejections
- Re-throw errors without adding context
- Return errors as values when exceptions are better
- Use errors for control flow

## Error Response Format

```json
{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid input data",
    "details": [{ "field": "email", "message": "Invalid format" }]
  }
}
```

Remember: Good error handling prevents debugging nightmares and provides a better user experience.

---

## Version
- v1.1.0 (2025-12-05): Split into references (typescript-patterns.md, python-patterns.md)
- v1.0.0 (2025-11-15): Initial version

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [benshapyro](https://github.com/benshapyro)
- **Source:** [benshapyro/cadre-devkit-claude](https://github.com/benshapyro/cadre-devkit-claude)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-benshapyro-cadre-devkit-claude-error-handler
- Seller: https://agentstack.voostack.com/s/benshapyro
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.