@cobrowser/chatgpt 0.2.0

package/README.md

@@ -0,0 +1,11 @@
+# `chatgpt`
+
+> TODO: description
+
+## Usage
+
+```
+const chatgpt = require('chatgpt');
+
+// TODO: DEMONSTRATE API
+```

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './services/TranslationService/TranslationService';

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./services/TranslationService/TranslationService"), exports);

package/dist/models/ChatGptMessage.d.ts

@@ -0,0 +1,14 @@
+export declare enum ChatGptRole {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system"
+}
+export interface ChatGptRequestBody {
+    model: string;
+    messages: ChatGptMessage[];
+}
+interface ChatGptMessage {
+    role: ChatGptRole;
+    content: string;
+}
+export default ChatGptMessage;

package/dist/models/ChatGptMessage.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGptRole = void 0;
+var ChatGptRole;
+(function (ChatGptRole) {
+    ChatGptRole["USER"] = "user";
+    ChatGptRole["ASSISTANT"] = "assistant";
+    ChatGptRole["SYSTEM"] = "system";
+})(ChatGptRole = exports.ChatGptRole || (exports.ChatGptRole = {}));

package/dist/services/BaseService/BaseService.d.ts

@@ -0,0 +1,25 @@
+import { AxiosError, AxiosInstance, AxiosResponse } from 'axios';
+declare class BaseService {
+    request: AxiosInstance;
+    readonly BASE_CHAT_COMPLETION_URL = "https://api.openai.com/v1/chat/completions";
+    chatGptModel: string;
+    maxNumberOfChatCompletionResult: number;
+    /**
+     *
+     * @param apiUrl Api url to be used to make API calls to openAI services
+     * @param model the main chatGPT model to use
+     * @param maxNumberOfChoices How many chat completion choices to generate for each request.
+     */
+    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number);
+    /**
+     * Filter the response from chatGpt API and only get the first choice
+     * @param response
+     */
+    getResponseFirstChoice(response: AxiosResponse): string | undefined;
+    /**
+     * function to handle requests errors
+     * @param error
+     */
+    handleErrors(error: AxiosError): void;
+}
+export default BaseService;

package/dist/services/BaseService/BaseService.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = __importDefault(require("../logger"));
+class BaseService {
+    /**
+     *
+     * @param apiUrl Api url to be used to make API calls to openAI services
+     * @param model the main chatGPT model to use
+     * @param maxNumberOfChoices How many chat completion choices to generate for each request.
+     */
+    constructor(apiUrl, model = 'gpt-3.5-turbo', maxNumberOfChoices = 1) {
+        Object.defineProperty(this, "request", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "BASE_CHAT_COMPLETION_URL", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'https://api.openai.com/v1/chat/completions'
+        });
+        Object.defineProperty(this, "chatGptModel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "maxNumberOfChatCompletionResult", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        this.request = axios_1.default.create({
+            baseURL: apiUrl || this.BASE_CHAT_COMPLETION_URL,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${process.env.OPEN_API_KEY} `,
+            },
+        });
+        this.chatGptModel = model;
+        this.maxNumberOfChatCompletionResult = maxNumberOfChoices;
+    }
+    /**
+     * Filter the response from chatGpt API and only get the first choice
+     * @param response
+     */
+    getResponseFirstChoice(response) {
+        var _a;
+        if ((_a = response.data.choices) === null || _a === void 0 ? void 0 : _a.length) {
+            const firstChatGptResponseMessage = response.data.choices[0].message;
+            logger_1.default.info(`First ChatGpt Message: ${firstChatGptResponseMessage.content}`);
+            return firstChatGptResponseMessage.content;
+        }
+        return undefined;
+    }
+    /**
+     * function to handle requests errors
+     * @param error
+     */
+    handleErrors(error) {
+        if (error.response) {
+            // The request was made and the server responded with a status code
+            // that falls out of the range of 2xx
+            logger_1.default.error(`response status code is  ${error.response.status}`);
+            logger_1.default.error(`response data ${error.response.data}`);
+        }
+        else if (error.request) {
+            // The request was made but no response was received
+            logger_1.default.error(error.request);
+        }
+        logger_1.default.error(`error message ${error.message}`);
+    }
+}
+exports.default = BaseService;

package/dist/services/TranslationService/TranslationService.d.ts

@@ -0,0 +1,12 @@
+import BaseService from '../BaseService/BaseService';
+export declare class TranslationService extends BaseService {
+    DESTINATION_LANGUAGE: string;
+    constructor(apiUrl?: string, model?: string, maxNumberOfChoices?: number);
+    /**
+     * request the chatGpt Api to translate a specific test to a desired language
+     * @param text the text to translate
+     * @param toLanguage the desired language to translate to ( English is the default )
+     * @param fromLanguage if we want to specify the language of the text, we can use this ( optional)
+     */
+    translate(text: string, toLanguage?: string, fromLanguage?: string): Promise<string | undefined>;
+}

package/dist/services/TranslationService/TranslationService.js

@@ -0,0 +1,63 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslationService = void 0;
+const ChatGptMessage_1 = require("../../models/ChatGptMessage");
+const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
+const logger_1 = __importDefault(require("../logger"));
+class TranslationService extends BaseService_1.default {
+    constructor(apiUrl, model, maxNumberOfChoices) {
+        super(apiUrl, model, maxNumberOfChoices);
+        Object.defineProperty(this, "DESTINATION_LANGUAGE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'English'
+        });
+    }
+    /**
+     * request the chatGpt Api to translate a specific test to a desired language
+     * @param text the text to translate
+     * @param toLanguage the desired language to translate to ( English is the default )
+     * @param fromLanguage if we want to specify the language of the text, we can use this ( optional)
+     */
+    translate(text, toLanguage = 'English', fromLanguage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!text) {
+                logger_1.default.error('translation text should be provided');
+                return Promise.reject(new Error('test must be provided'));
+            }
+            const desiredLanguage = toLanguage || this.DESTINATION_LANGUAGE, 
+            // instruction on what to do with the text
+            translateText = `Translate the following ${fromLanguage} text to ${desiredLanguage}: ${text}`, 
+            // the body we need to send to the request
+            requestBody = {
+                model: this.chatGptModel,
+                messages: [{
+                        role: ChatGptMessage_1.ChatGptRole.USER,
+                        content: translateText,
+                    }],
+            };
+            try {
+                const response = yield this.request.post('', requestBody);
+                return this.getResponseFirstChoice(response);
+            }
+            catch (e) {
+                this.handleErrors(e);
+                return Promise.reject(e);
+            }
+        });
+    }
+}
+exports.TranslationService = TranslationService;

package/dist/services/logger.d.ts

@@ -0,0 +1,2 @@
+declare const logger: any;
+export default logger;

package/dist/services/logger.js

@@ -0,0 +1,11 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const logger = require('@cobrowser/logger')({
+    level: (_a = process.env.LOG_LEVEL) !== null && _a !== void 0 ? _a : 'debug',
+    redact: ['secret.*'],
+    pretty: false,
+    timestamp: false,
+});
+exports.default = logger;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@cobrowser/chatgpt",
+  "version": "0.2.0",
+  "description": "chatgpt services to connect our projects with chatgpt api",
+  "keywords": [
+    "chatgpt",
+    "ai",
+    "API",
+    "services"
+  ],
+  "author": "Mostafa Tourad <mostafa@cobrowser.net>",
+  "homepage": "https://bitbucket.org/cobrowser/cb_utils#readme",
+  "main": "dist/index.js",
+  "scripts": {
+    "compile": "tsc -p tsconfig-build.json",
+    "test": "npx jest",
+    "lint": "npx eslint",
+    "lint-fix": "npm run lint -- --fix",
+    "security": "npm audit --production",
+    "upgrade": "npm outdated",
+    "precommit": "npm run lint && npm run test && npm run upgrade && npm run security"
+  },
+  "dependencies": {
+    "@cobrowser/logger": "^1.0.0",
+    "axios": "^1.3.5",
+    "axios-mock-adapter": "^1.21.4"
+  },
+  "directories": {
+    "dist": "dist"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@bitbucket.org/cobrowser/cb_utils.git"
+  },
+  "bugs": {
+    "url": "https://bitbucket.org/cobrowser/cb_utils/issues"
+  },
+  "gitHead": "116e8ba0b35f1fe2e5479fbac11033f346affd1b"
+}