Error Handler
Error Handler provides a structured approach to error management across Tauri's Rust backend and React frontend. It covers AppError enum definitions, three-layer error propagation from database through service to command layer, and frontend error handling with try-catch patterns and Ant Design components. The skill includes ErrorBoundary implementation, safe invoke wrappers, and best practices for avoiding panics and unhandled rejections.
Error Handler catches and manages errors across Rust backends and React frontends in Tauri applications.
AI-generated summary based on this skill's SKILL.md
Install
bkywksj/knowledge-base/error-handler · repository language: TypeScript
generated, unverified - the skill's exact subdirectory could not be determined; check the repository on GitHub
Open directory. Skills are indexed for reading, not audited. Review a skill's body before installing it.
Frequently asked questions
AI-generated answers based on this skill's SKILL.md and metadata
What is Error Handler and how does it work?
Error Handler provides a structured approach to error management across Tauri's Rust backend and React frontend. It covers AppError enum definitions, three-layer error propagation from database through service to command layer, and frontend error handling with try-catch patterns and Ant Design components. The skill includes ErrorBoundary implementation, safe invoke wrappers, and best practices for avoiding panics and unhandled rejections.
How do I catch and handle exceptions in Error Handler?
Error Handler enables catching and handling exceptions through a multi-layer approach. On the Rust backend, define AppError enums at the database, service, and command layers, allowing errors to propagate safely upward. On the React frontend, wrap components with ErrorBoundary, use try-catch blocks around async operations, and leverage safe invoke wrappers when calling Tauri commands. This prevents agent failures from interrupting workflows.
Can Error Handler debug errors automatically?
Yes, Error Handler supports debugging and logging errors for troubleshooting agent behavior. Implement error logging at each propagation layer to capture context from database through service to command level. Use frontend error logging to track unhandled rejections and component failures. This structured logging enables you to identify root causes and improve agent reliability.
How does Error Handler implement graceful error recovery?
Error Handler implements graceful error recovery through exception management best practices. Define clear error types in your AppError enum, use safe invoke wrappers to handle command failures, and implement ErrorBoundary components to catch React errors. This approach ensures that errors are caught at appropriate layers, logged for troubleshooting, and handled without causing panics or unhandled rejections that would interrupt workflows.
What error handling framework does Error Handler provide?
Error Handler provides a comprehensive error handling framework spanning Rust backend and React frontend. It includes AppError enum patterns for type-safe error definitions, three-layer error propagation architecture, safe invoke wrappers for command communication, ErrorBoundary components for UI error containment, and logging mechanisms for debugging. This framework prevents agent failures and ensures robust error management across your entire application.
How can I prevent runtime errors from breaking my agents?
Error Handler prevents runtime errors from breaking agents through layered error catching and recovery. Use try-catch patterns around async operations, wrap Tauri command invocations with safe invoke wrappers, and implement ErrorBoundary components in React. The three-layer propagation model ensures errors surface gracefully at the command layer rather than causing panics, allowing your agents to continue operating reliably.
Let your AI agent find skills like this
Example. Real query, live index.
You found this page by searching. An agent finds it by wishing: SkillFed indexes 56,283 agent skills by what they can do, searchable in plain language.
wish › “Automatically catch and handle errors in Claude Code and Codex agents”
Give your agent the search over MCP, or paste the wish link into any chat. No install? Search from any chat →
Related skills
Master error handling across Rust and TypeScript in Tauri applications. Learn custom error types, exception chains, API response patterns, and debugging techniques using tracing and structured logging. Covers database errors, command failures, and React error boundaries.
Master React 19 and TypeScript 5 component development with production-ready patterns for Ant Design, TanStack Query state management, and Tauri desktop apps. Learn Hooks best practices, form validation, performance optimization with React.memo and useCallback, and type-safe command integration without sacrificing developer experience.
This skill equips you with patterns for Tauri 2.0 desktop development, covering command definition with specta type generation, Rust-React integration, and proper error handling. Learn state management, async best practices, and desktop-specific constraints to avoid common pitfalls like blocking the async runtime or exposing sensitive errors.
Testing Strategy provides comprehensive testing patterns for Tauri applications spanning Rust backend and React frontend. It covers unit and integration tests, test fixtures, command mocking, and test coverage strategies to support quality assurance and TDD workflows.
Set up internationalization in Tauri applications using react-i18next to support multiple languages. Learn to organize translation files, use the translation hook in components, and enable runtime language switching. Covers configuration, common pitfalls, and best practices for managing localized content.
Tdd Workflow guides developers through test-first development using the red-green-refactor pattern: write failing tests, implement minimal code to pass, then refactor while maintaining test coverage. It covers unit and integration testing strategies for both Rust and TypeScript, with practical examples including validation logic, mocking external dependencies, and coverage verification tools. All new features and fixes must meet an 80% test coverage threshold.