public interface ChatBotService {

    InputStream createInputStream(
        ChatBotRequestModel request
    ) throws Exception;

    ChatBotOutputStream createOutputStream(
        ChatBotStreamHandler handler
    ) throws Exception;

    default boolean isAvailable() {
        return true;
    }

    String getServiceName();
}

public class ChatBotRequestModel {

    private ChatProfileModel profile;
    private String systemMessage;
    private List<ChatBotMessageModel> contextMessages;
    private long channelId;
    private long askerId;
    private String askerType;
}

for (ChatBotMessageModel message : request.getContextMessages()) {
    String role = message.getRole();
    String content = message.getContent();

    // Chuyển sang định dạng message của provider.
}

import com.tvd12.ezyfox.bean.annotation.EzySingleton;
import org.youngmonkeys.ezychat.sdk.handler.ChatBotStreamHandler;
import org.youngmonkeys.ezychat.sdk.io.ChatBotOutputStream;
import org.youngmonkeys.ezychat.sdk.model.ChatBotAnswerModel;
import org.youngmonkeys.ezychat.sdk.model.ChatBotRequestModel;
import org.youngmonkeys.ezychat.sdk.service.ChatBotService;

import java.io.InputStream;

@EzySingleton
public class CustomChatBotService implements ChatBotService {

    private final CustomAIClient aiClient;
    private final ThreadLocal<ChatBotRequestModel> pendingRequest =
        new ThreadLocal<>();

    public CustomChatBotService(CustomAIClient aiClient) {
        this.aiClient = aiClient;
    }

    @Override
    public String getServiceName() {
        return "custom-ai";
    }

    @Override
    public boolean isAvailable() {
        return aiClient.isConfigured();
    }

    @Override
    public InputStream createInputStream(
        ChatBotRequestModel request
    ) throws Exception {
        pendingRequest.set(request);

        return aiClient.openChatStream(
            request.getSystemMessage(),
            request.getContextMessages(),
            request.getProfile()
        );
    }

    @Override
    public ChatBotOutputStream createOutputStream(
        ChatBotStreamHandler handler
    ) {
        ChatBotRequestModel request = pendingRequest.get();
        pendingRequest.remove();

        return new CustomChatBotOutputStream(
            request,
            handler
        );
    }
}

import org.youngmonkeys.ezychat.sdk.handler.ChatBotStreamHandler;
import org.youngmonkeys.ezychat.sdk.io.ChatBotOutputStream;
import org.youngmonkeys.ezychat.sdk.model.ChatBotAnswerModel;
import org.youngmonkeys.ezychat.sdk.model.ChatBotRequestModel;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;

public class CustomChatBotOutputStream
    extends ChatBotOutputStream {

    private final ChatBotRequestModel request;
    private final ChatBotStreamHandler handler;
    private final StringBuilder content = new StringBuilder();

    public CustomChatBotOutputStream(
        ChatBotRequestModel request,
        ChatBotStreamHandler handler
    ) {
        this.request = request;
        this.handler = handler;
    }

    @Override
    public void write(int value) throws IOException {
        write(new byte[]{(byte) value}, 0, 1);
    }

    @Override
    public void write(
        byte[] bytes,
        int offset,
        int length
    ) throws IOException {
        String responseChunk = new String(
            bytes,
            offset,
            length,
            StandardCharsets.UTF_8
        );

        // Với SSE hoặc JSON streaming, hãy thay đoạn này
        // bằng bộ parser có khả năng giữ dữ liệu dở dang giữa các lần write.
        String delta = parseDelta(responseChunk);

        if (delta == null || delta.isEmpty()) {
            return;
        }

        content.append(delta);

        try {
            handler.onDelta(delta);
        } catch (Exception e) {
            throw new IOException(e);
        }
    }

    @Override
    public ChatBotAnswerModel getAnswer() {
        Map<String, Object> metadata = new LinkedHashMap<>();
        metadata.put("channelId", request.getChannelId());

        return ChatBotAnswerModel.builder()
            .serviceName("custom-ai")
            .profileName(request.getProfile().getName())
            .model(request.getProfile().getAiModel())
            .content(content.toString())
            .contentType("MARKDOWN")
            .stopReason("end_turn")
            .metadata(metadata)
            .build();
    }

    private String parseDelta(String chunk) {
        // Phân tích response thực tế của provider tại đây.
        return chunk;
    }
}

public interface ChatBotStreamHandler {

    void onDelta(String deltaContent) throws Exception;

    void onCompleted(ChatBotAnswerModel answer);

    void onError(Exception exception);
}

return ChatBotAnswerModel.builder()
    .serviceName("custom-ai")
    .profileName(profileName)
    .model(modelName)
    .content(answerContent)
    .contentType("MARKDOWN")
    .stopReason(stopReason)
    .inputTokens(inputTokens)
    .outputTokens(outputTokens)
    .metadata(metadata)
    .build();

@EzySingleton
public class CustomChatBotService implements ChatBotService {
    // ...
}

public class CustomChatBotService
    implements ChatBotService {
    // Toàn bộ logic dùng chung.
}

@EzySingleton
public class WebCustomChatBotService
    extends CustomChatBotService {
}

@EzySingleton
public class AdminCustomChatBotService
    extends CustomChatBotService {
}