openaicompatible.cpp

++ // Copyright (C) 2025 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0

++

++ #include "openaicompatible.h"

++ #include "translationsettings.h"

++ #include "translationutils.h"

++ #include "translatormessage.h"

++

++ #include <QtCore/qjsonarray.h>

++ #include <QtCore/qjsonobject.h>

++

++ using namespace Qt::Literals::StringLiterals;

++

++ QT_BEGIN_NAMESPACE

++

++ OpenAICompatible::OpenAICompatible()

++     : m_payloadBase(std::make_unique<QJsonObject>()),

++       m_formatTryCounter(TranslationSettings::maxJsonFormatTries())

++ {

++     m_payloadBase->insert("stream"_L1, false);

++     m_payloadBase->insert("temperature"_L1, TranslationSettings::temperature());

++ }

++

++ OpenAICompatible::~OpenAICompatible() = default;

++

++ QList<Batch> OpenAICompatible::makeBatches(const Messages &messages,

++                                            const QString &userContext) const

++ {

++     QHash<QString, QList<const TranslatorMessage *>> nonPluralGroups;

++     QHash<QString, QList<const TranslatorMessage *>> pluralGroups;

++

++     for (const auto &item : messages.items) {

++         const QString key = item->context() + item->label();

++         if (item->isPlural())

++             pluralGroups[key].append(item);

++         else

++             nonPluralGroups[key].append(item);

++     }

++

++     const int maxBatchSize = TranslationSettings::maxBatchSize();

++     QList<Batch> out;

++     out.reserve(nonPluralGroups.size() + pluralGroups.size());

++

++     auto createBatches = [&](const QHash<QString, QList<const TranslatorMessage *>> &groups,

++                              int pluralFormsCount) {

++         for (auto it = groups.cbegin(); it != groups.cend(); ++it) {

++             auto msgIt = it.value().cbegin();

++             while (msgIt != it.value().cend()) {

++                 Batch b;

++                 b.srcLang = messages.srcLang;

++                 b.tgtLang = messages.tgtLang;

++                 b.context = it.key();

++                 b.userContext = userContext;

++                 b.pluralFormsCount = pluralFormsCount;

++                 b.items.reserve(it.value().size());

++                 while (msgIt != it.value().cend() && b.items.size() < maxBatchSize) {

++                     Item item;

++                     item.msg = *msgIt;

++                     item.translation = item.msg->translation();

++                     b.items.append(std::move(item));

++                     msgIt++;

++                 }

++                 out.append(std::move(b));

++             }

++         }

++     };

++

++     createBatches(nonPluralGroups, 1);

++     createBatches(pluralGroups, messages.pluralFormsCount);

++

++     return out;

++ }

++

++ QHash<QString, QStringList> OpenAICompatible::extractTranslations(const QByteArray &response,

++                                                                   bool plural)

++ {

++     QJsonParseError err;

++     QJsonDocument doc = QJsonDocument::fromJson(response, &err);

++     if (err.error != QJsonParseError::NoError) {

++         decrementFormatCounter();

++         return {};

++     }

++

++     // OpenAI format: { "choices": [{ "message": { "content": "..." } }] }

++     const QJsonObject root = doc.object();

++     const QJsonArray choices = root.value("choices"_L1).toArray();

++     if (choices.isEmpty()) {

++         decrementFormatCounter();

++         return {};

++     }

++

++     const QJsonObject firstChoice = choices.first().toObject();

++     const QJsonObject message = firstChoice.value("message"_L1).toObject();

++     const QString content = message.value("content"_L1).toString();

++

++     // Parse the content as JSON to extract translations

++     QJsonDocument contentDoc = QJsonDocument::fromJson(content.toUtf8(), &err);

++     QJsonValue contentValue;

++     if (err.error == QJsonParseError::NoError) {

++         contentValue = contentDoc.object();

++     } else {

++         // Try to extract JSON from the content string

++         contentValue = content;

++     }

++

++     QHash<QString, QStringList> translations;

++     if (plural) {

++         translations = extractPluralTranslations(contentValue, "Plurals"_L1);

++     } else {

++         auto singleTranslations = extractKeyValuePairs(contentValue, "Translations"_L1);

++         for (auto it = singleTranslations.cbegin(); it != singleTranslations.cend(); ++it)

++             translations[it.key()] << it.value();

++     }

++

++     if (translations.isEmpty()) {

++         decrementFormatCounter();

++         return translations;

++     }

++

++     // Lock in the current format stage once we get a successful response.

++     // This prevents unnecessary fallback attempts due to occasional empty responses.

++     m_formatLocked = true;

++

++     return translations;

++ }

++

++ QStringList OpenAICompatible::extractModels(const QByteArray &response) const

++ {

++     QJsonParseError err;

++     QJsonDocument doc = QJsonDocument::fromJson(response, &err);

++     if (err.error != QJsonParseError::NoError)

++         return {};

++

++     // OpenAI format: { "data": [{ "id": "model-name", ... }] }

++     const QJsonObject obj = doc.object();

++     const QJsonArray arr = obj.value("data"_L1).toArray();

++     QStringList models;

++     for (const QJsonValue &v : arr)

++         models.append(v.toObject().value("id"_L1).toString());

++     return models;

++ }

++

++ QByteArray OpenAICompatible::payload(const Batch &b) const

++ {

++     QJsonObject systemMessage;

++     systemMessage.insert("role"_L1, "system"_L1);

++     const bool plural = b.pluralFormsCount > 1;

++     systemMessage.insert("content"_L1,

++                          plural ? pluralTranslationSystemPrompt() : translationSystemPrompt());

++

++     QJsonObject userMessage;

++     userMessage.insert("role"_L1, "user"_L1);

++     userMessage.insert("content"_L1, makePrompt(b));

++

++     QJsonArray messages;

++     messages.append(systemMessage);

++     messages.append(userMessage);

++

++     QJsonObject req = *m_payloadBase;

++     req.insert("messages"_L1, messages);

++

++     switch (m_formatStage) {

++     case JsonFormatStage::JsonObject: {

++         // llama.cpp style: {"type": "json_object"}

++         QJsonObject responseFormat;

++         responseFormat.insert("type"_L1, "json_object"_L1);

++         req.insert("response_format"_L1, responseFormat);

++         break;

++     }

++     case JsonFormatStage::JsonSchema: {

++         // LM Studio style: {"type": "json_schema", "json_schema": {...}}

++         QJsonObject schema;

++         schema.insert("type"_L1, "object"_L1);

++         QJsonObject properties;

++         QJsonObject translationsArray;

++         translationsArray.insert("type"_L1, "array"_L1);

++         properties.insert("Translations"_L1, translationsArray);

++         schema.insert("properties"_L1, properties);

++         QJsonArray required;

++         required.append("Translations"_L1);

++         schema.insert("required"_L1, required);

++

++         QJsonObject jsonSchema;

++         jsonSchema.insert("name"_L1, "translations"_L1);

++         jsonSchema.insert("schema"_L1, schema);

++

++         QJsonObject responseFormat;

++         responseFormat.insert("type"_L1, "json_schema"_L1);

++         responseFormat.insert("json_schema"_L1, jsonSchema);

++         req.insert("response_format"_L1, responseFormat);

++         break;

++     }

++     case JsonFormatStage::None:

++         // No response_format - rely on prompt instructions

++         break;

++     }

++

++     return QJsonDocument(req).toJson();

++ }

++

++ std::optional<QByteArray> OpenAICompatible::stageModel(const QString &modelName)

++ {

++     if (auto m = m_payloadBase->constFind("model"_L1);

++         m == m_payloadBase->constEnd() || *m != modelName) {

++         // Reset format fallback state for new model

++         m_formatStage = JsonFormatStage::JsonObject;

++         m_formatTryCounter = TranslationSettings::maxJsonFormatTries();

++         m_formatLocked = false;

++         m_payloadBase->insert("model"_L1, modelName);

++     }

++

++     // OpenAI-compatible servers typically don't need wake-up requests

++     // as they keep models loaded or handle loading transparently

++     return std::nullopt;

++ }

++

++ void OpenAICompatible::setUrl(const QString &url)

++ {

++     m_url = url;

++ }

++

++ QUrl OpenAICompatible::translationEndpoint() const

++ {

++     QString base = m_url;

++     if (!base.endsWith(u'/'))

++         base += u'/';

++     return QUrl(base + "v1/chat/completions"_L1);

++ }

++

++ QUrl OpenAICompatible::discoveryEndpoint() const

++ {

++     QString base = m_url;

++     if (!base.endsWith(u'/'))

++         base += u'/';

++     return QUrl(base + "v1/models"_L1);

++ }

++

++ void OpenAICompatible::onRequestRejected()

++ {

++     decrementFormatCounter();

++ }

++

++ void OpenAICompatible::decrementFormatCounter()

++ {

++     if (m_formatLocked)

++         return;

++

++     if (--m_formatTryCounter <= 0) {

++         // Move to next format stage

++         const int maxTries = TranslationSettings::maxJsonFormatTries();

++         switch (m_formatStage) {

++         case JsonFormatStage::JsonObject:

++             m_formatStage = JsonFormatStage::JsonSchema;

++             m_formatTryCounter = maxTries;

++             break;

++         case JsonFormatStage::JsonSchema:

++             m_formatStage = JsonFormatStage::None;

++             m_formatTryCounter = maxTries;

++             break;

++         case JsonFormatStage::None:

++             // Already at the last stage, nothing more to try

++             break;

++         }

++     }

++ }

++

++ QString OpenAICompatible::makePrompt(const Batch &b) const

++ {

++     QStringList lines;

++     lines.reserve(b.items.size() + 32);

++

++     if (!b.userContext.isEmpty())

++         lines << "Application Context: "_L1 + b.userContext;

++

++     lines << "Context: "_L1 + b.context;

++     lines << "Target: "_L1 + b.tgtLang;

++     if (b.pluralFormsCount > 1)

++         lines << "Plural forms: "_L1 + QString::number(b.pluralFormsCount);

++     lines << "Items:"_L1;

++     for (const Item &it : b.items) {

++         QString line = "- source: '%1'"_L1.arg(it.msg->sourceText());

++         if (const QString comment = it.msg->comment(); !comment.isEmpty())

++             line += ", comment: '%1'"_L1.arg(comment);

++         lines << line;

++     }

++

++     return lines.join(QLatin1Char('\n'));

++ }

++

++ QT_END_NAMESPACE

Revision control