axon-code 2.4.0

package/dist/types/errors.js

@@ -0,0 +1,670 @@
+/**
+ * 统一错误类型定义
+ * Axon 项目的标准错误处理系统
+ *
+ * 功能：
+ * - 统一的错误类型层次结构
+ * - 错误代码枚举
+ * - 错误工厂函数
+ * - 类型安全的错误处理
+ */
+// ============ 错误代码枚举 ============
+/**
+ * 错误代码枚举
+ * 使用分段管理：
+ * - 1000-1999: 工具相关错误
+ * - 2000-2999: 权限相关错误
+ * - 3000-3999: 配置相关错误
+ * - 4000-4999: 网络相关错误
+ * - 5000-5999: 认证相关错误
+ * - 6000-6999: 验证相关错误
+ * - 7000-7999: 会话相关错误
+ * - 8000-8999: 沙箱相关错误
+ * - 9000-9999: 系统相关错误
+ */
+export var ErrorCode;
+(function (ErrorCode) {
+    // ========== 工具相关错误 (1000-1999) ==========
+    ErrorCode[ErrorCode["TOOL_EXECUTION_FAILED"] = 1000] = "TOOL_EXECUTION_FAILED";
+    ErrorCode[ErrorCode["TOOL_NOT_FOUND"] = 1001] = "TOOL_NOT_FOUND";
+    ErrorCode[ErrorCode["TOOL_TIMEOUT"] = 1002] = "TOOL_TIMEOUT";
+    ErrorCode[ErrorCode["TOOL_INVALID_INPUT"] = 1003] = "TOOL_INVALID_INPUT";
+    ErrorCode[ErrorCode["TOOL_INVALID_OUTPUT"] = 1004] = "TOOL_INVALID_OUTPUT";
+    ErrorCode[ErrorCode["TOOL_NOT_AVAILABLE"] = 1005] = "TOOL_NOT_AVAILABLE";
+    ErrorCode[ErrorCode["TOOL_DISABLED"] = 1006] = "TOOL_DISABLED";
+    ErrorCode[ErrorCode["TOOL_DEPENDENCY_MISSING"] = 1007] = "TOOL_DEPENDENCY_MISSING";
+    // ========== 权限相关错误 (2000-2999) ==========
+    ErrorCode[ErrorCode["PERMISSION_DENIED"] = 2000] = "PERMISSION_DENIED";
+    ErrorCode[ErrorCode["PERMISSION_PATH_DENIED"] = 2001] = "PERMISSION_PATH_DENIED";
+    ErrorCode[ErrorCode["PERMISSION_COMMAND_DENIED"] = 2002] = "PERMISSION_COMMAND_DENIED";
+    ErrorCode[ErrorCode["PERMISSION_NETWORK_DENIED"] = 2003] = "PERMISSION_NETWORK_DENIED";
+    ErrorCode[ErrorCode["PERMISSION_TOOL_DENIED"] = 2004] = "PERMISSION_TOOL_DENIED";
+    ErrorCode[ErrorCode["PERMISSION_CONFIG_INVALID"] = 2005] = "PERMISSION_CONFIG_INVALID";
+    ErrorCode[ErrorCode["PERMISSION_AUDIT_FAILED"] = 2006] = "PERMISSION_AUDIT_FAILED";
+    // ========== 配置相关错误 (3000-3999) ==========
+    ErrorCode[ErrorCode["CONFIG_NOT_FOUND"] = 3000] = "CONFIG_NOT_FOUND";
+    ErrorCode[ErrorCode["CONFIG_INVALID"] = 3001] = "CONFIG_INVALID";
+    ErrorCode[ErrorCode["CONFIG_PARSE_ERROR"] = 3002] = "CONFIG_PARSE_ERROR";
+    ErrorCode[ErrorCode["CONFIG_VALIDATION_FAILED"] = 3003] = "CONFIG_VALIDATION_FAILED";
+    ErrorCode[ErrorCode["CONFIG_WRITE_FAILED"] = 3004] = "CONFIG_WRITE_FAILED";
+    ErrorCode[ErrorCode["CONFIG_MIGRATION_FAILED"] = 3005] = "CONFIG_MIGRATION_FAILED";
+    ErrorCode[ErrorCode["CONFIG_SCHEMA_ERROR"] = 3006] = "CONFIG_SCHEMA_ERROR";
+    ErrorCode[ErrorCode["CONFIG_MISSING_REQUIRED"] = 3007] = "CONFIG_MISSING_REQUIRED";
+    // ========== 网络相关错误 (4000-4999) ==========
+    ErrorCode[ErrorCode["NETWORK_CONNECTION_FAILED"] = 4000] = "NETWORK_CONNECTION_FAILED";
+    ErrorCode[ErrorCode["NETWORK_TIMEOUT"] = 4001] = "NETWORK_TIMEOUT";
+    ErrorCode[ErrorCode["NETWORK_DNS_FAILED"] = 4002] = "NETWORK_DNS_FAILED";
+    ErrorCode[ErrorCode["NETWORK_SSL_ERROR"] = 4003] = "NETWORK_SSL_ERROR";
+    ErrorCode[ErrorCode["NETWORK_PROXY_ERROR"] = 4004] = "NETWORK_PROXY_ERROR";
+    ErrorCode[ErrorCode["NETWORK_RATE_LIMITED"] = 4005] = "NETWORK_RATE_LIMITED";
+    ErrorCode[ErrorCode["NETWORK_OFFLINE"] = 4006] = "NETWORK_OFFLINE";
+    ErrorCode[ErrorCode["NETWORK_HOST_UNREACHABLE"] = 4007] = "NETWORK_HOST_UNREACHABLE";
+    // ========== 认证相关错误 (5000-5999) ==========
+    ErrorCode[ErrorCode["AUTH_FAILED"] = 5000] = "AUTH_FAILED";
+    ErrorCode[ErrorCode["AUTH_TOKEN_INVALID"] = 5001] = "AUTH_TOKEN_INVALID";
+    ErrorCode[ErrorCode["AUTH_TOKEN_EXPIRED"] = 5002] = "AUTH_TOKEN_EXPIRED";
+    ErrorCode[ErrorCode["AUTH_TOKEN_MISSING"] = 5003] = "AUTH_TOKEN_MISSING";
+    ErrorCode[ErrorCode["AUTH_OAUTH_FAILED"] = 5004] = "AUTH_OAUTH_FAILED";
+    ErrorCode[ErrorCode["AUTH_DEVICE_CODE_FAILED"] = 5005] = "AUTH_DEVICE_CODE_FAILED";
+    ErrorCode[ErrorCode["AUTH_REFRESH_FAILED"] = 5006] = "AUTH_REFRESH_FAILED";
+    ErrorCode[ErrorCode["AUTH_INSUFFICIENT_PERMISSIONS"] = 5007] = "AUTH_INSUFFICIENT_PERMISSIONS";
+    ErrorCode[ErrorCode["AUTH_API_KEY_INVALID"] = 5008] = "AUTH_API_KEY_INVALID";
+    ErrorCode[ErrorCode["AUTH_API_KEY_MISSING"] = 5009] = "AUTH_API_KEY_MISSING";
+    // ========== 验证相关错误 (6000-6999) ==========
+    ErrorCode[ErrorCode["VALIDATION_FAILED"] = 6000] = "VALIDATION_FAILED";
+    ErrorCode[ErrorCode["VALIDATION_SCHEMA_ERROR"] = 6001] = "VALIDATION_SCHEMA_ERROR";
+    ErrorCode[ErrorCode["VALIDATION_TYPE_ERROR"] = 6002] = "VALIDATION_TYPE_ERROR";
+    ErrorCode[ErrorCode["VALIDATION_REQUIRED_FIELD"] = 6003] = "VALIDATION_REQUIRED_FIELD";
+    ErrorCode[ErrorCode["VALIDATION_FORMAT_ERROR"] = 6004] = "VALIDATION_FORMAT_ERROR";
+    ErrorCode[ErrorCode["VALIDATION_RANGE_ERROR"] = 6005] = "VALIDATION_RANGE_ERROR";
+    ErrorCode[ErrorCode["VALIDATION_CONSTRAINT_VIOLATION"] = 6006] = "VALIDATION_CONSTRAINT_VIOLATION";
+    // ========== 会话相关错误 (7000-7999) ==========
+    ErrorCode[ErrorCode["SESSION_NOT_FOUND"] = 7000] = "SESSION_NOT_FOUND";
+    ErrorCode[ErrorCode["SESSION_INVALID"] = 7001] = "SESSION_INVALID";
+    ErrorCode[ErrorCode["SESSION_EXPIRED"] = 7002] = "SESSION_EXPIRED";
+    ErrorCode[ErrorCode["SESSION_SAVE_FAILED"] = 7003] = "SESSION_SAVE_FAILED";
+    ErrorCode[ErrorCode["SESSION_LOAD_FAILED"] = 7004] = "SESSION_LOAD_FAILED";
+    ErrorCode[ErrorCode["SESSION_CHECKPOINT_FAILED"] = 7005] = "SESSION_CHECKPOINT_FAILED";
+    ErrorCode[ErrorCode["SESSION_RESTORE_FAILED"] = 7006] = "SESSION_RESTORE_FAILED";
+    ErrorCode[ErrorCode["SESSION_NO_ACTIVE"] = 7007] = "SESSION_NO_ACTIVE";
+    // ========== 沙箱相关错误 (8000-8999) ==========
+    ErrorCode[ErrorCode["SANDBOX_INIT_FAILED"] = 8000] = "SANDBOX_INIT_FAILED";
+    ErrorCode[ErrorCode["SANDBOX_EXEC_FAILED"] = 8001] = "SANDBOX_EXEC_FAILED";
+    ErrorCode[ErrorCode["SANDBOX_RESOURCE_LIMIT"] = 8002] = "SANDBOX_RESOURCE_LIMIT";
+    ErrorCode[ErrorCode["SANDBOX_PATH_VIOLATION"] = 8003] = "SANDBOX_PATH_VIOLATION";
+    ErrorCode[ErrorCode["SANDBOX_NETWORK_BLOCKED"] = 8004] = "SANDBOX_NETWORK_BLOCKED";
+    ErrorCode[ErrorCode["SANDBOX_NOT_AVAILABLE"] = 8005] = "SANDBOX_NOT_AVAILABLE";
+    ErrorCode[ErrorCode["SANDBOX_CONFIG_INVALID"] = 8006] = "SANDBOX_CONFIG_INVALID";
+    ErrorCode[ErrorCode["SANDBOX_ESCAPE_ATTEMPT"] = 8007] = "SANDBOX_ESCAPE_ATTEMPT";
+    // ========== 系统相关错误 (9000-9999) ==========
+    ErrorCode[ErrorCode["SYSTEM_ERROR"] = 9000] = "SYSTEM_ERROR";
+    ErrorCode[ErrorCode["SYSTEM_FILE_NOT_FOUND"] = 9001] = "SYSTEM_FILE_NOT_FOUND";
+    ErrorCode[ErrorCode["SYSTEM_FILE_READ_ERROR"] = 9002] = "SYSTEM_FILE_READ_ERROR";
+    ErrorCode[ErrorCode["SYSTEM_FILE_WRITE_ERROR"] = 9003] = "SYSTEM_FILE_WRITE_ERROR";
+    ErrorCode[ErrorCode["SYSTEM_DIRECTORY_NOT_FOUND"] = 9004] = "SYSTEM_DIRECTORY_NOT_FOUND";
+    ErrorCode[ErrorCode["SYSTEM_PATH_INVALID"] = 9005] = "SYSTEM_PATH_INVALID";
+    ErrorCode[ErrorCode["SYSTEM_PERMISSION_DENIED"] = 9006] = "SYSTEM_PERMISSION_DENIED";
+    ErrorCode[ErrorCode["SYSTEM_OUT_OF_MEMORY"] = 9007] = "SYSTEM_OUT_OF_MEMORY";
+    ErrorCode[ErrorCode["SYSTEM_DISK_FULL"] = 9008] = "SYSTEM_DISK_FULL";
+    ErrorCode[ErrorCode["SYSTEM_PROCESS_FAILED"] = 9009] = "SYSTEM_PROCESS_FAILED";
+    // ========== 插件相关错误 (10000-10999) ==========
+    ErrorCode[ErrorCode["PLUGIN_NOT_FOUND"] = 10000] = "PLUGIN_NOT_FOUND";
+    ErrorCode[ErrorCode["PLUGIN_LOAD_FAILED"] = 10001] = "PLUGIN_LOAD_FAILED";
+    ErrorCode[ErrorCode["PLUGIN_INIT_FAILED"] = 10002] = "PLUGIN_INIT_FAILED";
+    ErrorCode[ErrorCode["PLUGIN_DEPENDENCY_MISSING"] = 10003] = "PLUGIN_DEPENDENCY_MISSING";
+    ErrorCode[ErrorCode["PLUGIN_CIRCULAR_DEPENDENCY"] = 10004] = "PLUGIN_CIRCULAR_DEPENDENCY";
+    ErrorCode[ErrorCode["PLUGIN_VERSION_MISMATCH"] = 10005] = "PLUGIN_VERSION_MISMATCH";
+    ErrorCode[ErrorCode["PLUGIN_INVALID_MANIFEST"] = 10006] = "PLUGIN_INVALID_MANIFEST";
+    ErrorCode[ErrorCode["PLUGIN_SECURITY_VIOLATION"] = 10007] = "PLUGIN_SECURITY_VIOLATION";
+    // ========== 未知错误 ==========
+    ErrorCode[ErrorCode["UNKNOWN_ERROR"] = 99999] = "UNKNOWN_ERROR";
+})(ErrorCode || (ErrorCode = {}));
+// ============ 错误严重级别 ============
+/**
+ * 错误严重级别
+ */
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    /** 低级：不影响主要功能，可以继续运行 */
+    ErrorSeverity["LOW"] = "low";
+    /** 中级：部分功能受影响，可能需要用户干预 */
+    ErrorSeverity["MEDIUM"] = "medium";
+    /** 高级：主要功能受影响，需要立即处理 */
+    ErrorSeverity["HIGH"] = "high";
+    /** 严重：系统无法正常运行，必须停止 */
+    ErrorSeverity["CRITICAL"] = "critical";
+})(ErrorSeverity || (ErrorSeverity = {}));
+// ============ 工具错误类型 ============
+/**
+ * 工具错误类型枚举
+ */
+export var ToolErrorType;
+(function (ToolErrorType) {
+    /** 权限被拒绝 */
+    ToolErrorType["PERMISSION_DENIED"] = "permission_denied";
+    /** 执行失败 */
+    ToolErrorType["EXECUTION_FAILED"] = "execution_failed";
+    /** 超时 */
+    ToolErrorType["TIMEOUT"] = "timeout";
+    /** 无效输入 */
+    ToolErrorType["INVALID_INPUT"] = "invalid_input";
+    /** 网络错误 */
+    ToolErrorType["NETWORK_ERROR"] = "network_error";
+    /** 沙箱错误 */
+    ToolErrorType["SANDBOX_ERROR"] = "sandbox_error";
+    /** 文件系统错误 */
+    ToolErrorType["FILE_SYSTEM_ERROR"] = "file_system_error";
+    /** MCP错误 */
+    ToolErrorType["MCP_ERROR"] = "mcp_error";
+    /** 未知错误 */
+    ToolErrorType["UNKNOWN"] = "unknown";
+})(ToolErrorType || (ToolErrorType = {}));
+// ============ 基础错误类 ============
+/**
+ * Claude 基础错误类
+ */
+export class BaseClaudeError extends Error {
+    code;
+    severity;
+    details;
+    recoverable;
+    retryable;
+    timestamp;
+    cause;
+    context;
+    toolErrorType;
+    constructor(code, message, options = {}) {
+        super(message);
+        this.name = 'ClaudeError';
+        this.code = code;
+        this.severity = options.severity ?? this.determineSeverity(code);
+        this.details = options.details;
+        this.recoverable = options.recoverable ?? this.determineRecoverable(code);
+        this.retryable = options.retryable ?? this.determineRetryable(code);
+        this.timestamp = Date.now();
+        this.cause = options.cause;
+        this.context = options.context;
+        this.toolErrorType = options.toolErrorType;
+        // 保持错误堆栈
+        if (options.cause && options.cause.stack) {
+            this.stack = `${this.stack}\nCaused by: ${options.cause.stack}`;
+        }
+        // 确保 instanceof 正常工作
+        Object.setPrototypeOf(this, BaseClaudeError.prototype);
+    }
+    /**
+     * 转换为 JSON 格式
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            severity: this.severity,
+            recoverable: this.recoverable,
+            retryable: this.retryable,
+            timestamp: this.timestamp,
+            details: this.details,
+            context: this.context,
+            toolErrorType: this.toolErrorType,
+        };
+    }
+    /**
+     * 根据错误代码判断严重级别
+     */
+    determineSeverity(code) {
+        // 认证错误
+        if (code >= 5000 && code < 6000) {
+            return ErrorSeverity.HIGH;
+        }
+        // 会话错误
+        if (code >= 7000 && code < 8000) {
+            return ErrorSeverity.MEDIUM;
+        }
+        // 配置错误
+        if (code >= 3000 && code < 4000) {
+            return ErrorSeverity.MEDIUM;
+        }
+        // 沙箱错误
+        if (code >= 8000 && code < 9000) {
+            return ErrorSeverity.HIGH;
+        }
+        // 系统错误
+        if (code >= 9000 && code < 10000) {
+            return ErrorSeverity.HIGH;
+        }
+        // 默认中级
+        return ErrorSeverity.MEDIUM;
+    }
+    /**
+     * 根据错误代码判断是否可恢复
+     */
+    determineRecoverable(code) {
+        const unrecoverableCodes = [
+            ErrorCode.CONFIG_SCHEMA_ERROR,
+            ErrorCode.VALIDATION_SCHEMA_ERROR,
+            ErrorCode.PLUGIN_CIRCULAR_DEPENDENCY,
+            ErrorCode.SANDBOX_ESCAPE_ATTEMPT,
+            ErrorCode.SYSTEM_OUT_OF_MEMORY,
+            ErrorCode.SYSTEM_DISK_FULL,
+        ];
+        return !unrecoverableCodes.includes(code);
+    }
+    /**
+     * 根据错误代码判断是否可重试
+     */
+    determineRetryable(code) {
+        const retryableCodes = [
+            ErrorCode.NETWORK_CONNECTION_FAILED,
+            ErrorCode.NETWORK_TIMEOUT,
+            ErrorCode.NETWORK_RATE_LIMITED,
+            ErrorCode.AUTH_REFRESH_FAILED,
+            ErrorCode.SESSION_LOAD_FAILED,
+            ErrorCode.SYSTEM_FILE_READ_ERROR,
+            ErrorCode.TOOL_TIMEOUT,
+        ];
+        return retryableCodes.includes(code);
+    }
+}
+// ============ 具体错误类型 ============
+/**
+ * 工具执行错误
+ */
+export class ToolExecutionError extends BaseClaudeError {
+    toolName;
+    constructor(message, toolName, options = {}) {
+        super(ErrorCode.TOOL_EXECUTION_FAILED, message, {
+            ...options,
+            toolErrorType: options.toolErrorType ?? ToolErrorType.EXECUTION_FAILED,
+            context: { ...options.context, toolName },
+        });
+        this.name = 'ToolExecutionError';
+        this.toolName = toolName;
+        Object.setPrototypeOf(this, ToolExecutionError.prototype);
+    }
+}
+/**
+ * 工具超时错误
+ */
+export class ToolTimeoutError extends BaseClaudeError {
+    toolName;
+    timeout;
+    constructor(message, toolName, timeout, options = {}) {
+        super(ErrorCode.TOOL_TIMEOUT, message, {
+            ...options,
+            toolErrorType: ToolErrorType.TIMEOUT,
+            retryable: true,
+            context: { ...options.context, toolName, timeout },
+        });
+        this.name = 'ToolTimeoutError';
+        this.toolName = toolName;
+        this.timeout = timeout;
+        Object.setPrototypeOf(this, ToolTimeoutError.prototype);
+    }
+}
+/**
+ * 权限拒绝错误
+ */
+export class PermissionDeniedError extends BaseClaudeError {
+    resource;
+    permissionType;
+    constructor(message, resource, permissionType, options = {}) {
+        super(ErrorCode.PERMISSION_DENIED, message, {
+            ...options,
+            recoverable: false,
+            context: { ...options.context, resource, permissionType },
+        });
+        this.name = 'PermissionDeniedError';
+        this.resource = resource;
+        this.permissionType = permissionType;
+        Object.setPrototypeOf(this, PermissionDeniedError.prototype);
+    }
+}
+/**
+ * 配置错误
+ */
+export class ConfigurationError extends BaseClaudeError {
+    configPath;
+    validationErrors;
+    constructor(message, configPath, validationErrors, options = {}) {
+        super(ErrorCode.CONFIG_INVALID, message, {
+            ...options,
+            context: { ...options.context, configPath, validationErrors },
+        });
+        this.name = 'ConfigurationError';
+        this.configPath = configPath;
+        this.validationErrors = validationErrors;
+        Object.setPrototypeOf(this, ConfigurationError.prototype);
+    }
+}
+/**
+ * 网络错误
+ */
+export class NetworkError extends BaseClaudeError {
+    url;
+    statusCode;
+    constructor(message, url, statusCode, options = {}) {
+        super(ErrorCode.NETWORK_CONNECTION_FAILED, message, {
+            ...options,
+            retryable: true,
+            context: { ...options.context, url, statusCode },
+        });
+        this.name = 'NetworkError';
+        this.url = url;
+        this.statusCode = statusCode;
+        Object.setPrototypeOf(this, NetworkError.prototype);
+    }
+}
+/**
+ * 认证错误
+ */
+export class AuthenticationError extends BaseClaudeError {
+    authType;
+    constructor(message, authType, options = {}) {
+        super(ErrorCode.AUTH_FAILED, message, {
+            ...options,
+            severity: ErrorSeverity.HIGH,
+            recoverable: false,
+            context: { ...options.context, authType },
+        });
+        this.name = 'AuthenticationError';
+        this.authType = authType;
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+/**
+ * 验证错误
+ */
+export class ValidationError extends BaseClaudeError {
+    field;
+    validationErrors;
+    constructor(message, field, validationErrors, options = {}) {
+        super(ErrorCode.VALIDATION_FAILED, message, {
+            ...options,
+            recoverable: false,
+            context: { ...options.context, field, validationErrors },
+        });
+        this.name = 'ValidationError';
+        this.field = field;
+        this.validationErrors = validationErrors;
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+/**
+ * 会话错误
+ */
+export class SessionError extends BaseClaudeError {
+    sessionId;
+    constructor(message, sessionId, options = {}) {
+        super(ErrorCode.SESSION_NOT_FOUND, message, {
+            ...options,
+            context: { ...options.context, sessionId },
+        });
+        this.name = 'SessionError';
+        this.sessionId = sessionId;
+        Object.setPrototypeOf(this, SessionError.prototype);
+    }
+}
+/**
+ * 沙箱错误
+ */
+export class SandboxError extends BaseClaudeError {
+    sandboxType;
+    resourceLimit;
+    constructor(message, sandboxType, resourceLimit, options = {}) {
+        super(ErrorCode.SANDBOX_INIT_FAILED, message, {
+            ...options,
+            severity: ErrorSeverity.HIGH,
+            context: { ...options.context, sandboxType, resourceLimit },
+        });
+        this.name = 'SandboxError';
+        this.sandboxType = sandboxType;
+        this.resourceLimit = resourceLimit;
+        Object.setPrototypeOf(this, SandboxError.prototype);
+    }
+}
+/**
+ * 插件错误
+ */
+export class PluginError extends BaseClaudeError {
+    pluginName;
+    pluginVersion;
+    constructor(message, pluginName, pluginVersion, options = {}) {
+        super(ErrorCode.PLUGIN_LOAD_FAILED, message, {
+            ...options,
+            context: { ...options.context, pluginName, pluginVersion },
+        });
+        this.name = 'PluginError';
+        this.pluginName = pluginName;
+        this.pluginVersion = pluginVersion;
+        Object.setPrototypeOf(this, PluginError.prototype);
+    }
+}
+/**
+ * 系统错误
+ */
+export class SystemError extends BaseClaudeError {
+    systemCode;
+    systemMessage;
+    constructor(message, systemCode, systemMessage, options = {}) {
+        super(ErrorCode.SYSTEM_ERROR, message, {
+            ...options,
+            severity: ErrorSeverity.HIGH,
+            context: { ...options.context, systemCode, systemMessage },
+        });
+        this.name = 'SystemError';
+        this.systemCode = systemCode;
+        this.systemMessage = systemMessage;
+        Object.setPrototypeOf(this, SystemError.prototype);
+    }
+}
+// ============ 错误工厂函数 ============
+/**
+ * 创建工具执行错误
+ */
+export function createToolExecutionError(toolName, message, options) {
+    return new ToolExecutionError(message, toolName, options);
+}
+/**
+ * 创建权限拒绝错误
+ */
+export function createPermissionDeniedError(resource, permissionType, message, options) {
+    const defaultMessage = `Permission denied: ${permissionType} access to ${resource}`;
+    return new PermissionDeniedError(message || defaultMessage, resource, permissionType, options);
+}
+/**
+ * 创建配置错误
+ */
+export function createConfigurationError(message, configPath, validationErrors, options) {
+    return new ConfigurationError(message, configPath, validationErrors, options);
+}
+/**
+ * 创建网络错误
+ */
+export function createNetworkError(message, url, statusCode, options) {
+    return new NetworkError(message, url, statusCode, options);
+}
+/**
+ * 创建认证错误
+ */
+export function createAuthenticationError(message, authType, options) {
+    return new AuthenticationError(message, authType, options);
+}
+/**
+ * 创建验证错误
+ */
+export function createValidationError(message, field, validationErrors, options) {
+    return new ValidationError(message, field, validationErrors, options);
+}
+/**
+ * 创建会话错误
+ */
+export function createSessionError(message, sessionId, options) {
+    return new SessionError(message, sessionId, options);
+}
+/**
+ * 创建沙箱错误
+ */
+export function createSandboxError(message, sandboxType, resourceLimit, options) {
+    return new SandboxError(message, sandboxType, resourceLimit, options);
+}
+/**
+ * 创建插件错误
+ */
+export function createPluginError(message, pluginName, pluginVersion, options) {
+    return new PluginError(message, pluginName, pluginVersion, options);
+}
+/**
+ * 创建系统错误
+ */
+export function createSystemError(message, systemCode, systemMessage, options) {
+    return new SystemError(message, systemCode, systemMessage, options);
+}
+// ============ 错误转换函数 ============
+/**
+ * 从原生错误创建 Claude 错误
+ */
+export function fromNativeError(error, code = ErrorCode.UNKNOWN_ERROR, options = {}) {
+    const nativeError = error instanceof Error ? error : new Error(String(error));
+    return new BaseClaudeError(code, nativeError.message, {
+        ...options,
+        cause: nativeError,
+    });
+}
+/**
+ * 判断是否为 Claude 错误
+ */
+export function isClaudeError(error) {
+    return (error instanceof BaseClaudeError ||
+        (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            'severity' in error &&
+            'recoverable' in error &&
+            'retryable' in error));
+}
+/**
+ * 判断错误是否可恢复
+ */
+export function isRecoverableError(error) {
+    if (isClaudeError(error)) {
+        return error.recoverable;
+    }
+    return false;
+}
+/**
+ * 判断错误是否可重试
+ */
+export function isRetryableError(error) {
+    if (isClaudeError(error)) {
+        return error.retryable;
+    }
+    return false;
+}
+/**
+ * 格式化错误为人类可读字符串
+ */
+export function formatError(error, verbose = false) {
+    if (isClaudeError(error)) {
+        const parts = [];
+        // 错误名称和消息
+        parts.push(`${error.name}: ${error.message}`);
+        // 错误代码
+        parts.push(`  Code: ${error.code} (${ErrorCode[error.code] || 'Unknown'})`);
+        // 严重级别
+        parts.push(`  Severity: ${error.severity}`);
+        // 可恢复性和重试性
+        const flags = [];
+        if (error.recoverable)
+            flags.push('recoverable');
+        if (error.retryable)
+            flags.push('retryable');
+        if (flags.length > 0) {
+            parts.push(`  Flags: ${flags.join(', ')}`);
+        }
+        // 上下文信息
+        if (error.context && Object.keys(error.context).length > 0) {
+            parts.push(`  Context: ${JSON.stringify(error.context)}`);
+        }
+        // 详细信息
+        if (verbose) {
+            // 时间戳
+            parts.push(`  Timestamp: ${new Date(error.timestamp).toISOString()}`);
+            // 详细数据
+            if (error.details) {
+                parts.push(`  Details: ${JSON.stringify(error.details, null, 2)}`);
+            }
+            // 原因链
+            if (error.cause) {
+                parts.push(`  Caused by: ${error.cause.message}`);
+                if (error.cause.stack) {
+                    parts.push(`    ${error.cause.stack.split('\n').slice(0, 3).join('\n    ')}`);
+                }
+            }
+            // 堆栈跟踪
+            if (error.stack) {
+                parts.push(`  Stack: ${error.stack.split('\n').slice(1, 4).join('\n  ')}`);
+            }
+        }
+        return parts.join('\n');
+    }
+    // 非 Claude 错误
+    if (error instanceof Error) {
+        return verbose
+            ? `${error.name}: ${error.message}\n${error.stack}`
+            : `${error.name}: ${error.message}`;
+    }
+    return String(error);
+}
+/**
+ * 获取错误的严重级别
+ */
+export function getErrorSeverity(error) {
+    if (isClaudeError(error)) {
+        return error.severity;
+    }
+    return ErrorSeverity.MEDIUM;
+}
+/**
+ * 获取错误代码
+ */
+export function getErrorCode(error) {
+    if (isClaudeError(error)) {
+        return error.code;
+    }
+    return ErrorCode.UNKNOWN_ERROR;
+}
+// ============ 错误处理辅助函数 ============
+/**
+ * 包装函数，自动捕获和转换错误
+ */
+export function wrapWithErrorHandling(fn, errorCode, context) {
+    return (...args) => {
+        try {
+            return fn(...args);
+        }
+        catch (error) {
+            if (isClaudeError(error)) {
+                throw error;
+            }
+            throw fromNativeError(error, errorCode, { context });
+        }
+    };
+}
+/**
+ * 包装异步函数，自动捕获和转换错误
+ */
+export function wrapAsyncWithErrorHandling(fn, errorCode, context) {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (error) {
+            if (isClaudeError(error)) {
+                throw error;
+            }
+            throw fromNativeError(error, errorCode, { context });
+        }
+    };
+}
+//# sourceMappingURL=errors.js.map