@anam-ai/js-sdk/dist/module/modules/CoreApiRestClient.js

Client side JavaScript SDK for Anam AI

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { ClientError, ErrorCode } from '../lib/ClientError';
import { DEFAULT_API_BASE_URL, DEFAULT_API_VERSION } from '../lib/constants';
import { isCustomPersonaConfig } from '../types/PersonaConfig';
export class CoreApiRestClient {
    constructor(sessionToken, apiKey, options) {
        if (!sessionToken && !apiKey) {
            throw new Error('Either sessionToken or apiKey must be provided');
        }
        this.sessionToken = sessionToken || null;
        this.apiKey = apiKey || null;
        this.baseUrl = (options === null || options === void 0 ? void 0 : options.baseUrl) || DEFAULT_API_BASE_URL;
        this.apiVersion = (options === null || options === void 0 ? void 0 : options.apiVersion) || DEFAULT_API_VERSION;
    }
    startSession(personaConfig, sessionOptions) {
        return __awaiter(this, void 0, void 0, function* () {
            if (!this.sessionToken) {
                if (!personaConfig) {
                    throw new ClientError('Persona configuration must be provided when using apiKey', ErrorCode.CLIENT_ERROR_CODE_VALIDATION_ERROR, 400);
                }
                // TODO: why do we need to get the unsafe session token here?
                this.sessionToken = yield this.unsafe_getSessionToken(personaConfig);
            }
            try {
                const response = yield fetch(`${this.getApiUrl()}/engine/session`, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        Authorization: `Bearer ${this.sessionToken}`,
                    },
                    body: JSON.stringify({ personaConfig, sessionOptions }),
                });
                const data = yield response.json();
                switch (response.status) {
                    case 200:
                    case 201:
                        return data;
                    case 400:
                        throw new ClientError('Invalid request to start session', ErrorCode.CLIENT_ERROR_CODE_VALIDATION_ERROR, 400, { cause: data.message });
                    case 401:
                        throw new ClientError('Authentication failed when starting session', ErrorCode.CLIENT_ERROR_CODE_AUTHENTICATION_ERROR, 401, { cause: data.message });
                    case 402:
                        throw new ClientError('Please sign up for a plan to start a session', ErrorCode.CLIENT_ERROR_CODE_NO_PLAN_FOUND, 402, { cause: data.message });
                    case 403:
                        throw new ClientError('Authentication failed when starting session', ErrorCode.CLIENT_ERROR_CODE_AUTHENTICATION_ERROR, 403, { cause: data.message });
                    case 429:
                        throw new ClientError('Out of credits, please upgrade your plan', ErrorCode.CLIENT_ERROR_CODE_USAGE_LIMIT_REACHED, 429, { cause: data.message });
                    case 503:
                        throw new ClientError('There are no available personas, please try again later', ErrorCode.CLIENT_ERROR_CODE_SERVICE_BUSY, 503, { cause: data.message });
                    default:
                        throw new ClientError('Unknown error when starting session', ErrorCode.CLIENT_ERROR_CODE_SERVER_ERROR, 500, { cause: data.message });
                }
            }
            catch (error) {
                if (error instanceof ClientError) {
                    throw error;
                }
                throw new ClientError('Failed to start session', ErrorCode.CLIENT_ERROR_CODE_SERVER_ERROR, 500, { cause: error instanceof Error ? error.message : String(error) });
            }
        });
    }
    unsafe_getSessionToken(personaConfig) {
        return __awaiter(this, void 0, void 0, function* () {
            console.warn('Using unsecure method. This method should not be used in production.');
            if (!this.apiKey) {
                throw new Error('No apiKey provided');
            }
            let body = {
                clientLabel: 'js-sdk-api-key',
            };
            if (isCustomPersonaConfig(personaConfig)) {
                body = Object.assign(Object.assign({}, body), { personaConfig });
            }
            try {
                const response = yield fetch(`${this.getApiUrl()}/auth/session-token`, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                        Authorization: `Bearer ${this.apiKey}`,
                    },
                    body: JSON.stringify(body),
                });
                const data = yield response.json();
                return data.sessionToken;
            }
            catch (e) {
                throw new Error('Failed to get session token');
            }
        });
    }
    getApiUrl() {
        return `${this.baseUrl}${this.apiVersion}`;
    }
}
//# sourceMappingURL=CoreApiRestClient.js.map