@cobrowser/chatgpt 0.7.36 → 0.7.38

package/dist/index.d.ts

@@ -2,3 +2,4 @@ export * from './services/TranslationService/TranslationService';
 export * from './services/CopilotService/CopilotService';
 export * from './services/ChatService/ChatService';
 export * from './services/AssistantService/AssistantService';
+export * from './services/ResponseService/ResponseService';

package/dist/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./services/TranslationService/TranslationService"), export
 __exportStar(require("./services/CopilotService/CopilotService"), exports);
 __exportStar(require("./services/ChatService/ChatService"), exports);
 __exportStar(require("./services/AssistantService/AssistantService"), exports);
+__exportStar(require("./services/ResponseService/ResponseService"), exports);

package/dist/services/AssistantService/AssistantService.js

@@ -68,7 +68,10 @@ class AssistantService extends BaseService_1.default {
             const openai = new openai_1.default({ apiKey: this.openaiApiKey });
             let run;
             if (runOptions.functionOutputs && this.runId) {
-                run = yield openai.beta.threads.runs.submitToolOutputsAndPoll(this.threadId, this.runId, { tool_outputs: JSON.parse(runOptions.functionOutputs) });
+                run = yield openai.beta.threads.runs.submitToolOutputsAndPoll(this.runId, {
+                    thread_id: this.threadId,
+                    tool_outputs: JSON.parse(runOptions.functionOutputs)
+                });
             }
             else {
                 const lastThreadMessasges = yield openai.beta.threads.messages.list(this.threadId, { order: "desc", limit: 2 }), isRepeatedMessage = lastThreadMessasges.data.find(msg => msg.content[0].type === 'text' && msg.content[0].text.value === message);
@@ -94,7 +97,7 @@ class AssistantService extends BaseService_1.default {
             }
             while (['queued', 'in_progress', 'cancelling'].includes(run.status)) {
                 yield new Promise(resolve => setTimeout(resolve, 500));
-                run = yield openai.beta.threads.runs.retrieve(run.thread_id, run.id);
+                run = yield openai.beta.threads.runs.retrieve(run.id, { thread_id: run.thread_id });
             }
             if (run.status === 'completed') {
                 const { data } = yield openai.beta.threads.messages.list(run.thread_id, { order: 'desc', limit: 1 }), messages = data.flatMap((message) => message === null || message === void 0 ? void 0 : message.content.map((content) => ((content.type === 'text' && message.role === 'assistant') ? content.text : ''))), assistantMessages = messages.filter(message => typeof message === 'object' && 'value' in message && typeof message.value === 'string');

package/dist/services/BaseService/BaseService.js

@@ -84,10 +84,14 @@ class BaseService {
                 (methodName.startsWith('get') &&
                     !methodName.startsWith('getReply') &&
                     !methodName.startsWith('getAssist') &&
-                    !methodName.startsWith('getChat')) ||
+                    !methodName.startsWith('getChat') &&
+                    !methodName.startsWith('getPrompt')) ||
                 methodName.startsWith('handle') ||
                 methodName.includes('Sanitize') ||
-                methodName.includes('sanitize')) {
+                methodName.includes('sanitize') ||
+                methodName.includes('createConversation') ||
+                methodName.includes('isAssistantIdFormat') ||
+                methodName.includes('isPromptIdFormat')) {
                 continue;
             }
             const originalMethod = method.bind(this);

package/dist/services/CopilotService/CopilotService.d.ts

@@ -4,6 +4,7 @@ export declare class CopilotService extends BaseService {
     #private;
     assistantId: string | undefined;
     threadId: string | undefined;
+    conversationId: string | undefined;
     constructor(apiKey?: string, model?: string, assistantId?: string, threadId?: string, apiUrl?: string, maxNumberOfChoices?: number);
     /**
      * a method to be used to suggest some quick replies for the agent based on the conversation
@@ -30,4 +31,7 @@ export declare class CopilotService extends BaseService {
      * @param message
      */
     getAssistantSuggestions(conversation: string): Promise<ChatGPTResponse | undefined>;
+    private isAssistantIdFormat;
+    private isPromptIdFormat;
+    getPromptSuggestions(message: string): Promise<ChatGPTResponse | undefined>;
 }

package/dist/services/CopilotService/CopilotService.js

@@ -39,6 +39,12 @@ class CopilotService extends BaseService_1.default {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "conversationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.assistantId = assistantId;
         this.threadId = threadId;
     }
@@ -62,7 +68,19 @@ class CopilotService extends BaseService_1.default {
             }
             try {
                 if (this.assistantId) {
-                    return yield this.getAssistantSuggestions(conversation);
+                    // Here we get the last customer message as we dont need the whole conversation
+                    // as we are doing with the other approach
+                    const conversationArray = conversation.split('\n');
+                    const lastCustomerMessage = conversationArray.reverse().find(e => e.includes('customer:'));
+                    if (!lastCustomerMessage) {
+                        logger_1.default.error('last customer message not found');
+                        return Promise.reject(new Error('last customer message not found'));
+                    }
+                    // Route based on id shape: asst_* => Assistant API, prompt_* => Responses API
+                    if (yield this.isAssistantIdFormat(this.assistantId)) {
+                        return yield this.getAssistantSuggestions(conversation);
+                    }
+                    return yield this.getPromptSuggestions(lastCustomerMessage);
                 }
                 return yield this.getChatCompletionSuggestions(conversation);
             }
@@ -105,49 +123,154 @@ class CopilotService extends BaseService_1.default {
      * @param message
      */
     getAssistantSuggestions(conversation) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            // Here we get the last customer message as we dont need the whole conversation
-            // as we are doing with the other approach.
-            const conversationArray = conversation.split('\n'), lastCustomerMessage = conversationArray.reverse().find(e => e.includes('customer:'));
-            if (!lastCustomerMessage) {
-                logger_1.default.error('Last customer message not found');
-                return Promise.reject(new Error('Last customer message not found'));
+            const conversationLines = conversation.split('\n').filter(line => line.trim());
+            const messages = [];
+            for (const line of conversationLines) {
+                if (line.includes('customer:')) {
+                    messages.push({
+                        role: 'user',
+                        content: line.replace(/^customer:\s*/, '').trim()
+                    });
+                }
+                else if (line.includes('agent:')) {
+                    messages.push({
+                        role: 'assistant',
+                        content: line.replace(/^agent:\s*/, '').trim()
+                    });
+                }
+            }
+            if (messages.length === 0) {
+                logger_1.default.error('No valid messages found in conversation');
+                return Promise.reject(new Error('No valid messages found in conversation'));
             }
             const openai = new openai_1.default({ apiKey: this.openaiApiKey });
-            let run;
+            let thread;
             if (!this.threadId) {
-                const thread = yield openai.beta.threads.create();
+                thread = yield openai.beta.threads.create({
+                    metadata: {
+                        lastMessageIndex: '-1'
+                    }
+                });
                 this.threadId = thread.id;
             }
-            const lastThreadMessasges = yield openai.beta.threads.messages.list(this.threadId, { order: "desc", limit: 2 }), isRepeatedMessage = lastThreadMessasges.data.find(msg => msg.content[0].type === 'text' && msg.content[0].text.value === lastCustomerMessage);
-            // making sure that we're not saving repeated messages
-            if (isRepeatedMessage) {
-                const runs = yield openai.beta.threads.runs.list(this.threadId, { order: "desc", limit: 1 });
-                run = runs.data[0];
-            }
             else {
-                yield openai.beta.threads.messages.create(this.threadId, { role: "user", content: lastCustomerMessage });
-                run = yield openai.beta.threads.runs.create(this.threadId, { assistant_id: (_a = this.assistantId) !== null && _a !== void 0 ? _a : '' });
+                thread = yield openai.beta.threads.retrieve(this.threadId);
+            }
+            const lastMessageIndex = parseInt(((_a = thread.metadata) === null || _a === void 0 ? void 0 : _a.lastMessageIndex) || '-1', 10);
+            const newMessages = messages.slice(lastMessageIndex + 1);
+            if (newMessages.length === 0) {
+                // Retrieve the last assistant message from the thread
+                const { data } = yield openai.beta.threads.messages.list(this.threadId, { order: 'desc', limit: 10 });
+                const lastAssistantMessage = data.find(msg => msg.role === 'assistant');
+                if (lastAssistantMessage) {
+                    const messagesData = lastAssistantMessage.content.map((content) => content.type === 'text' ? content.text : '').filter(text => text);
+                    if (messagesData.length) {
+                        const answers = messagesData.map(message => message.value);
+                        return {
+                            data: __classPrivateFieldGet(this, _CopilotService_instances, "m", _CopilotService_processSuggestions).call(this, answers),
+                            threadId: this.threadId,
+                            usageTokens: undefined,
+                        };
+                    }
+                }
+                return Promise.reject(new Error('No previous assistant messages found'));
+            }
+            for (const message of newMessages) {
+                yield openai.beta.threads.messages.create(this.threadId, {
+                    role: message.role,
+                    content: message.content
+                });
             }
-            while (['queued', 'in_progress', 'cancelling'].includes(run.status)) {
+            yield openai.beta.threads.update(this.threadId, {
+                metadata: {
+                    lastMessageIndex: (messages.length - 1).toString()
+                }
+            });
+            const run = yield openai.beta.threads.runs.create(this.threadId, {
+                assistant_id: (_b = this.assistantId) !== null && _b !== void 0 ? _b : ''
+            });
+            let currentRun = run;
+            while (['queued', 'in_progress', 'cancelling'].includes(currentRun.status)) {
                 yield new Promise(resolve => setTimeout(resolve, 500));
-                run = yield openai.beta.threads.runs.retrieve(run.thread_id, run.id);
+                currentRun = yield openai.beta.threads.runs.retrieve(currentRun.id, { thread_id: currentRun.thread_id });
             }
-            if (run.status === 'completed') {
-                const { data } = yield openai.beta.threads.messages.list(run.thread_id, { order: 'desc', limit: 1 }), messages = data.flatMap((message) => message === null || message === void 0 ? void 0 : message.content.map((content) => ((content.type === 'text' && message.role === 'assistant') ? content.text : ''))), assistantMessages = messages.filter(message => typeof message === 'object' && 'value' in message && typeof message.value === 'string');
+            if (currentRun.status === 'completed') {
+                const { data } = yield openai.beta.threads.messages.list(currentRun.thread_id, { order: 'desc', limit: 1 }), messagesData = data.flatMap((message) => message === null || message === void 0 ? void 0 : message.content.map((content) => ((content.type === 'text' && message.role === 'assistant') ? content.text : ''))), assistantMessages = messagesData.filter(message => typeof message === 'object' && 'value' in message && typeof message.value === 'string');
                 if (assistantMessages.length) {
                     const answers = assistantMessages.map(message => message.value);
                     return {
                         data: __classPrivateFieldGet(this, _CopilotService_instances, "m", _CopilotService_processSuggestions).call(this, answers),
-                        threadId: run.thread_id,
-                        usageTokens: run.usage,
+                        threadId: currentRun.thread_id,
+                        usageTokens: currentRun.usage,
                     };
                 }
             }
             return undefined;
         });
     }
+    isAssistantIdFormat(id) {
+        return !!id && /^asst_[A-Za-z0-9]+$/.test(id);
+    }
+    isPromptIdFormat(id) {
+        return !!id && /^pmpt_[A-Za-z0-9]+$/.test(id);
+    }
+    getPromptSuggestions(message) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        return __awaiter(this, void 0, void 0, function* () {
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            let conversationId = this.conversationId;
+            if (!conversationId) {
+                const conv = yield openai.conversations.create();
+                conversationId = conv.id;
+            }
+            const request = {
+                //model: this.chatGptModel || 'gpt-4o-mini',
+                input: message,
+                store: true,
+                conversation: { id: conversationId },
+                include: ['file_search_call.results'],
+            };
+            if (this.assistantId && (yield this.isPromptIdFormat(this.assistantId))) {
+                request.prompt = { id: this.assistantId };
+            }
+            const response = yield openai.responses.create(request);
+            response.output.forEach((item, index) => {
+            });
+            if ((_a = response.conversation) === null || _a === void 0 ? void 0 : _a.id) {
+                this.conversationId = response.conversation.id;
+            }
+            // Sometimes if the prompt needs a file search, the output will be an array of messages
+            // which includes multiple messages (some of them are not useful for the user, but the last one is)
+            const output = response.output || [];
+            const assistantMessages = output.filter((item) => item.type === 'message' && item.role === 'assistant');
+            if (assistantMessages.length) {
+                const text = assistantMessages.flatMap((m) => { var _a, _b; return ((_b = (_a = m.content) === null || _a === void 0 ? void 0 : _a.filter((c) => c.type === 'output_text')) === null || _b === void 0 ? void 0 : _b.map((c) => c.text)) || []; });
+                return {
+                    data: [text.pop()],
+                    threadId: this.conversationId,
+                    usageTokens: {
+                        prompt_tokens: Number((_c = ((_b = response.usage) === null || _b === void 0 ? void 0 : _b.prompt_tokens)) !== null && _c !== void 0 ? _c : 0),
+                        completion_tokens: Number((_e = ((_d = response.usage) === null || _d === void 0 ? void 0 : _d.completion_tokens)) !== null && _e !== void 0 ? _e : 0),
+                        total_tokens: Number((_g = ((_f = response.usage) === null || _f === void 0 ? void 0 : _f.total_tokens)) !== null && _g !== void 0 ? _g : 0),
+                    },
+                };
+            }
+            if (response.output_text) {
+                return {
+                    data: [response.output_text],
+                    threadId: this.conversationId,
+                    usageTokens: {
+                        prompt_tokens: Number((_j = ((_h = response.usage) === null || _h === void 0 ? void 0 : _h.prompt_tokens)) !== null && _j !== void 0 ? _j : 0),
+                        completion_tokens: Number((_l = ((_k = response.usage) === null || _k === void 0 ? void 0 : _k.completion_tokens)) !== null && _l !== void 0 ? _l : 0),
+                        total_tokens: Number((_o = ((_m = response.usage) === null || _m === void 0 ? void 0 : _m.total_tokens)) !== null && _o !== void 0 ? _o : 0),
+                    },
+                };
+            }
+            return undefined;
+        });
+    }
 }
 exports.CopilotService = CopilotService;
 _CopilotService_instances = new WeakSet(), _CopilotService_processSuggestions = function _CopilotService_processSuggestions(suggestions) {

package/dist/services/ResponseService/ResponseService.d.ts

@@ -0,0 +1,34 @@
+import ChatGPTResponse from '../../models/ChatGPTResponse';
+import BaseService from '../BaseService/BaseService';
+interface ResponseServiceOptions {
+    instructions?: string;
+    tools?: any[];
+    functionOutputs?: string;
+    definedSchema?: any;
+    conversationId?: string;
+}
+export declare class ResponseService extends BaseService {
+    promptId: string | undefined;
+    conversationId: string | undefined;
+    lastResponseId: string | undefined;
+    constructor(apiKey?: string, promptId?: string, conversationId?: string);
+    /**
+     * Create a new conversation
+     */
+    createConversation(): Promise<string>;
+    /**
+     * Get the reply using the Response API
+     *
+     * @param message
+     * @param runOptions
+     */
+    getReply(message: string, runOptions?: ResponseServiceOptions): Promise<ChatGPTResponse | undefined>;
+    reset(): void;
+    getConversationId(): string | undefined;
+    getLastResponseId(): string | undefined;
+    getPromptId(): string | undefined;
+    setPromptId(promptId: string): void;
+    setConversationId(conversationId: string): void;
+    setLastResponseId(lastResponseId: string): void;
+}
+export {};

package/dist/services/ResponseService/ResponseService.js

@@ -0,0 +1,193 @@
+"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.ResponseService = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const openai_1 = __importDefault(require("openai"));
+const BaseService_1 = __importDefault(require("../BaseService/BaseService"));
+class ResponseService extends BaseService_1.default {
+    constructor(apiKey, promptId, conversationId) {
+        super(apiKey);
+        Object.defineProperty(this, "promptId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "conversationId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastResponseId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promptId = promptId;
+        this.conversationId = conversationId;
+    }
+    /**
+     * Create a new conversation
+     */
+    createConversation() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            const conversation = yield openai.conversations.create();
+            this.conversationId = conversation.id;
+            return this.conversationId;
+        });
+    }
+    /**
+     * Get the reply using the Response API
+     *
+     * @param message
+     * @param runOptions
+     */
+    getReply(message, runOptions = {}) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.promptId) {
+                logger_1.default.error('Prompt ID is required for Response API');
+                return Promise.reject(new Error('Prompt ID is required for Response API'));
+            }
+            logger_1.default.info(`New response with message: ${message} & options: ${JSON.stringify(runOptions)}`);
+            const openai = new openai_1.default({ apiKey: this.openaiApiKey });
+            try {
+                const responseRequest = {
+                    store: true,
+                };
+                // Handle function outputs
+                if (runOptions.functionOutputs) {
+                    const toolOutputs = JSON.parse(runOptions.functionOutputs);
+                    const formattedInputs = toolOutputs.map((output) => ({
+                        type: 'function_call_output',
+                        call_id: output.call_id,
+                        output: output.output
+                    }));
+                    responseRequest.input = formattedInputs;
+                    const conversationIdToUse = runOptions.conversationId || this.conversationId;
+                    if (!conversationIdToUse) {
+                        const createdId = yield this.createConversation();
+                        this.conversationId = createdId;
+                    }
+                    responseRequest.conversation = runOptions.conversationId || this.conversationId;
+                }
+                else {
+                    // Handle regular message
+                    if (!runOptions.conversationId && !this.conversationId) {
+                        const createdId = yield this.createConversation();
+                        this.conversationId = createdId;
+                    }
+                    responseRequest.input = message;
+                    responseRequest.include = ['file_search_call.results'];
+                    if (runOptions.instructions) {
+                        responseRequest.instructions = runOptions.instructions;
+                    }
+                    const conversationIdToUse = runOptions.conversationId || this.conversationId;
+                    if (conversationIdToUse) {
+                        responseRequest.conversation = conversationIdToUse;
+                    }
+                    if ((_a = runOptions.tools) === null || _a === void 0 ? void 0 : _a.length) {
+                        responseRequest.tools = runOptions.tools;
+                    }
+                    if (runOptions.definedSchema) {
+                        responseRequest.text = {
+                            format: runOptions.definedSchema
+                        };
+                    }
+                }
+                if (this.promptId) {
+                    responseRequest.prompt = {
+                        id: this.promptId
+                    };
+                }
+                const response = yield openai.responses.create(responseRequest);
+                this.lastResponseId = response.id;
+                if ((_b = response.conversation) === null || _b === void 0 ? void 0 : _b.id) {
+                    this.conversationId = response.conversation.id;
+                }
+                else if (runOptions.conversationId) {
+                    this.conversationId = runOptions.conversationId;
+                }
+                // Process response output
+                const output = response.output || [];
+                const assistantMessages = output.filter((item) => item.type === 'message' && item.role === 'assistant');
+                const functionCalls = output.filter((item) => item.type === 'function_call');
+                if (functionCalls.length > 0) {
+                    return {
+                        requiredActions: JSON.stringify(functionCalls),
+                        threadId: this.conversationId,
+                        usageTokens: response.usage,
+                    };
+                }
+                if (assistantMessages.length > 0) {
+                    const textContent = assistantMessages
+                        .flatMap((msg) => msg.content || [])
+                        .filter((content) => content.type === 'output_text' || content.type === 'text')
+                        .map((content) => content.text || content.value)
+                        .filter((text) => text);
+                    if (textContent.length > 0) {
+                        return {
+                            data: textContent.pop(),
+                            threadId: this.conversationId,
+                            usageTokens: response.usage,
+                        };
+                    }
+                }
+                if (response.output_text) {
+                    return {
+                        data: response.output_text,
+                        threadId: this.conversationId,
+                        usageTokens: response.usage,
+                    };
+                }
+                return {
+                    data: undefined,
+                    threadId: this.conversationId,
+                    usageTokens: response.usage,
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Error in ResponseService.getReply:', error);
+                return Promise.reject(error);
+            }
+        });
+    }
+    reset() {
+        this.lastResponseId = undefined;
+        this.conversationId = undefined;
+    }
+    getConversationId() {
+        return this.conversationId;
+    }
+    getLastResponseId() {
+        return this.lastResponseId;
+    }
+    getPromptId() {
+        return this.promptId;
+    }
+    setPromptId(promptId) {
+        this.promptId = promptId;
+    }
+    setConversationId(conversationId) {
+        this.conversationId = conversationId;
+    }
+    setLastResponseId(lastResponseId) {
+        this.lastResponseId = lastResponseId;
+    }
+}
+exports.ResponseService = ResponseService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cobrowser/chatgpt",
-  "version": "0.7.36",
+  "version": "0.7.38",
   "description": "chatgpt services to connect our projects with chatgpt api",
   "keywords": [
     "chatgpt",
@@ -25,7 +25,7 @@
     "@cobrowser/xss-validation": "^2.0.1",
     "axios": "^1.6.1",
     "axios-mock-adapter": "^1.22.0",
-    "openai": "^4.86.2"
+    "openai": "^6.3.0"
   },
   "directories": {
     "dist": "dist"
@@ -40,5 +40,5 @@
   "bugs": {
     "url": "https://bitbucket.org/cobrowser/cb_utils/issues"
   },
-  "gitHead": "7a5961aa09cb038da19c5e23e25996158b2f1dfa"
+  "gitHead": "484f4a9b9f39d973f01113f8caa148eff0a41be5"
 }