234 lines
11 KiB
JavaScript
234 lines
11 KiB
JavaScript
/*
|
|
* ThunderAI [https://micz.it/thunderbird-addon-thunderai/]
|
|
* Copyright (C) 2024 - 2025 Mic (m@micz.it)
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
// Call the API to use a special prompt
|
|
|
|
import { prefs_default } from "../options/mzta-options-default.js";
|
|
import { taLogger } from './mzta-logger.js';
|
|
|
|
export class mzta_specialCommand {
|
|
|
|
prompt = "";
|
|
worker = null;
|
|
llm = "";
|
|
custom_model = "";
|
|
full_message = "";
|
|
logger = null;
|
|
do_debug = false;
|
|
config = {};
|
|
|
|
constructor(args = {}) {
|
|
let {
|
|
prompt = '',
|
|
llm = '',
|
|
custom_model = '',
|
|
do_debug = false,
|
|
config = {}
|
|
} = args;
|
|
this.prompt = prompt;
|
|
this.llm = llm;
|
|
this.custom_model = custom_model;
|
|
this.config = config;
|
|
this.logger = new taLogger('mzta_specialCommand', do_debug);
|
|
this.do_debug = do_debug;
|
|
switch (this.llm) {
|
|
case "chatgpt_api":
|
|
this.worker = new Worker(new URL('./workers/model-worker-openai_responses.js', import.meta.url), { type: 'module' });
|
|
break;
|
|
case "google_gemini_api":
|
|
this.worker = new Worker(new URL('./workers/model-worker-google_gemini.js', import.meta.url), { type: 'module' });
|
|
break;
|
|
case "ollama_api":
|
|
this.worker = new Worker(new URL('./workers/model-worker-ollama.js', import.meta.url), { type: 'module' });
|
|
break;
|
|
case "openai_comp_api":
|
|
this.worker = new Worker(new URL('./workers/model-worker-openai_comp.js', import.meta.url), { type: 'module' });
|
|
break;
|
|
case "anthropic_api":
|
|
this.worker = new Worker(new URL('./workers/model-worker-anthropic.js', import.meta.url), { type: 'module' });
|
|
break;
|
|
default:
|
|
this.logger.log("Invalid LLM type: " + this.llm);
|
|
throw new Error("Invalid LLM type: " + this.llm);
|
|
}
|
|
}
|
|
|
|
async initWorker() {
|
|
// console.log((">>>>>>>>>>>> this.custom_model: " + this.custom_model));
|
|
switch (this.llm) {
|
|
case "chatgpt_api": {
|
|
let prefs_api = await browser.storage.sync.get({
|
|
chatgpt_api_key: prefs_default.chatgpt_api_key,
|
|
chatgpt_model: prefs_default.chatgpt_model,
|
|
chatgpt_developer_messages: prefs_default.chatgpt_developer_messages,
|
|
});
|
|
|
|
if (this.config.chatgpt_api_key) prefs_api.chatgpt_api_key = this.config.chatgpt_api_key;
|
|
if (this.config.chatgpt_model) prefs_api.chatgpt_model = this.config.chatgpt_model;
|
|
if (this.config.chatgpt_developer_messages) prefs_api.chatgpt_developer_messages = this.config.chatgpt_developer_messages;
|
|
|
|
this.worker.postMessage({
|
|
type: 'init',
|
|
chatgpt_api_key: prefs_api.chatgpt_api_key,
|
|
chatgpt_model: this.custom_model != '' ? this.custom_model : prefs_api.chatgpt_model,
|
|
chatgpt_developer_messages: prefs_api.chatgpt_developer_messages,
|
|
do_debug: this.do_debug,
|
|
i18nStrings: ''
|
|
});
|
|
break;
|
|
}
|
|
case "google_gemini_api": {
|
|
let prefs_api = await browser.storage.sync.get({
|
|
google_gemini_api_key: prefs_default.google_gemini_api_key,
|
|
google_gemini_model: prefs_default.google_gemini_model,
|
|
google_gemini_system_instruction: prefs_default.google_gemini_system_instruction,
|
|
google_gemini_thinking_budget: prefs_default.google_gemini_thinking_budget,
|
|
});
|
|
|
|
if (this.config.google_gemini_api_key) prefs_api.google_gemini_api_key = this.config.google_gemini_api_key;
|
|
if (this.config.google_gemini_model) prefs_api.google_gemini_model = this.config.google_gemini_model;
|
|
if (this.config.google_gemini_system_instruction) prefs_api.google_gemini_system_instruction = this.config.google_gemini_system_instruction;
|
|
if (this.config.google_gemini_thinking_budget) prefs_api.google_gemini_thinking_budget = this.config.google_gemini_thinking_budget;
|
|
|
|
this.worker.postMessage({
|
|
type: 'init',
|
|
google_gemini_api_key: prefs_api.google_gemini_api_key,
|
|
google_gemini_model: this.custom_model != '' ? this.custom_model : prefs_api.google_gemini_model,
|
|
google_gemini_system_instruction: prefs_api.google_gemini_system_instruction,
|
|
google_gemini_thinking_budget: prefs_api.google_gemini_thinking_budget,
|
|
do_debug: this.do_debug,
|
|
i18nStrings: ''
|
|
});
|
|
break;
|
|
}
|
|
case "ollama_api": {
|
|
let prefs_api = await browser.storage.sync.get({
|
|
ollama_host: prefs_default.ollama_host,
|
|
ollama_model: prefs_default.ollama_model,
|
|
});
|
|
|
|
if (this.config.ollama_host) prefs_api.ollama_host = this.config.ollama_host;
|
|
if (this.config.ollama_model) prefs_api.ollama_model = this.config.ollama_model;
|
|
|
|
this.worker.postMessage({
|
|
type: 'init',
|
|
ollama_host: prefs_api.ollama_host,
|
|
ollama_model: this.custom_model != '' ? this.custom_model : prefs_api.ollama_model,
|
|
do_debug: this.do_debug,
|
|
i18nStrings: ''
|
|
});
|
|
break;
|
|
}
|
|
case "openai_comp_api": {
|
|
let prefs_api = await browser.storage.sync.get({
|
|
openai_comp_host: prefs_default.openai_comp_host,
|
|
openai_comp_model: prefs_default.openai_comp_model,
|
|
openai_comp_api_key: prefs_default.openai_comp_api_key,
|
|
openai_comp_use_v1: prefs_default.openai_comp_use_v1,
|
|
openai_comp_chat_name: prefs_default.openai_comp_chat_name,
|
|
do_debug: prefs_default.do_debug,
|
|
});
|
|
|
|
if (this.config.openai_comp_host) prefs_api.openai_comp_host = this.config.openai_comp_host;
|
|
if (this.config.openai_comp_model) prefs_api.openai_comp_model = this.config.openai_comp_model;
|
|
if (this.config.openai_comp_api_key) prefs_api.openai_comp_api_key = this.config.openai_comp_api_key;
|
|
if (this.config.openai_comp_use_v1 !== undefined) prefs_api.openai_comp_use_v1 = this.config.openai_comp_use_v1;
|
|
if (this.config.openai_comp_chat_name) prefs_api.openai_comp_chat_name = this.config.openai_comp_chat_name;
|
|
|
|
this.worker.postMessage({
|
|
type: 'init',
|
|
openai_comp_host: prefs_api.openai_comp_host,
|
|
openai_comp_model: this.custom_model != '' ? this.custom_model : prefs_api.openai_comp_model,
|
|
openai_comp_api_key: prefs_api.openai_comp_api_key,
|
|
openai_comp_use_v1: prefs_api.openai_comp_use_v1,
|
|
do_debug: this.do_debug,
|
|
i18nStrings: ''
|
|
});
|
|
break;
|
|
}
|
|
case "anthropic_api": {
|
|
let prefs_api = await browser.storage.sync.get({
|
|
anthropic_api_key: prefs_default.anthropic_api_key,
|
|
anthropic_model: prefs_default.anthropic_model,
|
|
anthropic_version: prefs_default.anthropic_version,
|
|
anthropic_max_tokens: prefs_default.anthropic_max_tokens,
|
|
});
|
|
|
|
if (this.config.anthropic_api_key) prefs_api.anthropic_api_key = this.config.anthropic_api_key;
|
|
if (this.config.anthropic_model) prefs_api.anthropic_model = this.config.anthropic_model;
|
|
if (this.config.anthropic_version) prefs_api.anthropic_version = this.config.anthropic_version;
|
|
if (this.config.anthropic_max_tokens) prefs_api.anthropic_max_tokens = this.config.anthropic_max_tokens;
|
|
|
|
this.worker.postMessage({
|
|
type: 'init',
|
|
anthropic_api_key: prefs_api.anthropic_api_key,
|
|
anthropic_model: this.custom_model != '' ? this.custom_model : prefs_api.anthropic_model,
|
|
anthropic_version: prefs_api.anthropic_version,
|
|
anthropic_max_tokens: prefs_api.anthropic_max_tokens,
|
|
do_debug: this.do_debug,
|
|
i18nStrings: ''
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
sendPrompt(){
|
|
return new Promise((resolve, reject) => {
|
|
// Event listeners for worker messages
|
|
this.worker.onmessage = (event) => {
|
|
const { type, payload } = event.data;
|
|
// console.log(`>>>>>>>>>>>> [Worker Message Received] type: ${type}`, payload);
|
|
switch (type) {
|
|
case 'messageSent':
|
|
break;
|
|
case 'newToken':
|
|
this.full_message += payload.token;
|
|
break;
|
|
case 'tokensDone':
|
|
this.logger.log("tokensDone: " + this.full_message);
|
|
resolve(this.full_message); // Resolve the promise with the full message
|
|
break;
|
|
case 'error':
|
|
console.error('[ThunderAI] Error from API worker:', payload);
|
|
reject(new Error(`[ThunderAI] Error from API worker: ${payload}`)); // Use a single error object
|
|
break;
|
|
default:
|
|
console.error('[ThunderAI] Unknown event type from API worker:', type);
|
|
}
|
|
};
|
|
|
|
this.worker.onerror = (error) => {
|
|
console.error('[ThunderAI] Worker Error Details:');
|
|
console.error('Message:', error.message);
|
|
console.error('Filename:', error.filename);
|
|
console.error('Line Number:', error.lineno);
|
|
console.error('Column Number:', error.colno);
|
|
console.error('Event:', error);
|
|
reject(error);
|
|
};
|
|
|
|
try {
|
|
// console.log('[ThunderAI] Sending prompt to worker:', this.prompt);
|
|
this.worker.postMessage({ type: 'chatMessage', message: this.prompt });
|
|
} catch (error) {
|
|
console.error('[ThunderAI] Failed to send message to worker:', error);
|
|
reject(error);
|
|
}
|
|
});
|
|
}
|
|
}
|