@inworld/web-core/build/src/entities/error.entity.js

import { ErrorType as ProtoErrorType, ReconnectionType as ProtoErrorReconnectionType, ResourceType as ProtoErrorResourceType, } from '../../proto/ai/inworld/common/status.pb.js';
export var ErrorType;
(function (ErrorType) {
    ErrorType["SESSION_TOKEN_EXPIRED"] = "SESSION_TOKEN_EXPIRED";
    ErrorType["SESSION_TOKEN_INVALID"] = "SESSION_TOKEN_INVALID";
    ErrorType["SESSION_RESOURCES_EXHAUSTED"] = "SESSION_RESOURCES_EXHAUSTED";
    ErrorType["BILLING_TOKENS_EXHAUSTED"] = "BILLING_TOKENS_EXHAUSTED";
    ErrorType["ACCOUNT_DISABLED"] = "ACCOUNT_DISABLED";
    ErrorType["SESSION_INVALID"] = "SESSION_INVALID";
    ErrorType["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
    ErrorType["SAFETY_VIOLATION"] = "SAFETY_VIOLATION";
    ErrorType["SESSION_EXPIRED"] = "SESSION_EXPIRED";
    ErrorType["AUDIO_SESSION_EXPIRED"] = "AUDIO_SESSION_EXPIRED";
    ErrorType["SESSION_PAUSED"] = "SESSION_PAUSED";
})(ErrorType || (ErrorType = {}));
export var ErrorReconnectionType;
(function (ErrorReconnectionType) {
    ErrorReconnectionType["UNDEFINED"] = "UNDEFINED";
    ErrorReconnectionType["NO_RETRY"] = "NO_RETRY";
    ErrorReconnectionType["IMMEDIATE"] = "IMMEDIATE";
    ErrorReconnectionType["TIMEOUT"] = "TIMEOUT";
})(ErrorReconnectionType || (ErrorReconnectionType = {}));
export var ErrorResourceType;
(function (ErrorResourceType) {
    ErrorResourceType["RESOURCE_TYPE_UNDEFINED"] = "RESOURCE_TYPE_UNDEFINED";
    ErrorResourceType["RESOURCE_TYPE_CONVERSATION"] = "RESOURCE_TYPE_CONVERSATION";
})(ErrorResourceType || (ErrorResourceType = {}));
export class InworldError {
    constructor(message, code, details) {
        this.details = [];
        this.message = message;
        this.code = code;
        this.details = details;
    }
    static fromProto(proto) {
        var _a;
        const details = (_a = proto.details) === null || _a === void 0 ? void 0 : _a.map((d) => (Object.assign({ errorType: this.getErrorType(d.errorType), reconnectType: this.getErrorReconnectionType(d.reconnectType), reconnectTime: d.reconnectTime, maxRetries: d.maxRetries }, (d.resourceNotFound && {
            resourceNotFound: {
                resourceId: d.resourceNotFound.resourceId,
                resourceType: this.getErrorResourceType(d.resourceNotFound.resourceType),
            },
        }))));
        return new InworldError(proto.message, proto.code, details);
    }
    static getErrorType(errorType) {
        switch (errorType) {
            case ProtoErrorType.SESSION_TOKEN_EXPIRED:
                return ErrorType.SESSION_TOKEN_EXPIRED;
            case ProtoErrorType.SESSION_TOKEN_INVALID:
                return ErrorType.SESSION_TOKEN_INVALID;
            case ProtoErrorType.SESSION_RESOURCES_EXHAUSTED:
                return ErrorType.SESSION_RESOURCES_EXHAUSTED;
            case ProtoErrorType.BILLING_TOKENS_EXHAUSTED:
                return ErrorType.BILLING_TOKENS_EXHAUSTED;
            case ProtoErrorType.ACCOUNT_DISABLED:
                return ErrorType.ACCOUNT_DISABLED;
            case ProtoErrorType.SESSION_INVALID:
                return ErrorType.SESSION_INVALID;
            case ProtoErrorType.RESOURCE_NOT_FOUND:
                return ErrorType.RESOURCE_NOT_FOUND;
            case ProtoErrorType.SAFETY_VIOLATION:
                return ErrorType.SAFETY_VIOLATION;
            case ProtoErrorType.SESSION_EXPIRED:
                return ErrorType.SESSION_EXPIRED;
            case ProtoErrorType.AUDIO_SESSION_EXPIRED:
                return ErrorType.AUDIO_SESSION_EXPIRED;
            case ProtoErrorType.SESSION_PAUSED:
                return ErrorType.SESSION_PAUSED;
            default:
                return undefined;
        }
    }
    static getErrorReconnectionType(reconnectType) {
        switch (reconnectType) {
            case ProtoErrorReconnectionType.UNDEFINED:
                return ErrorReconnectionType.UNDEFINED;
            case ProtoErrorReconnectionType.NO_RETRY:
                return ErrorReconnectionType.NO_RETRY;
            case ProtoErrorReconnectionType.IMMEDIATE:
                return ErrorReconnectionType.IMMEDIATE;
            case ProtoErrorReconnectionType.TIMEOUT:
                return ErrorReconnectionType.TIMEOUT;
            default:
                return undefined;
        }
    }
    static getErrorResourceType(resourceType) {
        switch (resourceType) {
            case ProtoErrorResourceType.RESOURCE_TYPE_CONVERSATION:
                return ErrorResourceType.RESOURCE_TYPE_CONVERSATION;
            default:
                return ErrorResourceType.RESOURCE_TYPE_UNDEFINED;
        }
    }
}