Method continueDataModelStreaming

core/src/stream/agenui_text_stream_plugin.cpp:254–433

}

bool TextStreamPlugin::continueDataModelStreaming(
    const std::string& buffer,
    std::vector<ProtocolStreamExtractor::ParseResult>& outResults,
    size_t& outEndPosition) {

    // 1. Check whether the complete JSON is closed
    size_t jsonStart = 0;
    while (jsonStart < buffer.length()) {
        char c = buffer[jsonStart];
        if (c != ' ' && c != '\n' && c != '\r' && c != '\t') {
            break;
        }
        jsonStart++;
    }

    if (jsonStart < buffer.length() && buffer[jsonStart] == '{') {
        size_t endPos = 0;
        if (ProtocolStreamExtractor::isJsonObjectComplete(buffer, jsonStart, endPos)) {
            // JSON is complete; send the final appendDataModel delta for each entry
            for (auto& entry : _streamingEntries) {
                size_t closePos = 0;
                if (!isStringValueClosed(buffer, entry.leafValueStart, closePos)) {
                    continue;
                }
                std::string delta = extractDelta(buffer, entry.lastSentEnd, closePos);

                if (!delta.empty()) {
                    std::string eventJson = buildAppendDataModelJson(entry, delta);
                    if (!eventJson.empty()) {
                        ProtocolStreamExtractor::ParseResult result;
                        result.type = ProtocolStreamExtractor::ParseResult::Type::NormalEvent;
                        result.eventType = ProtocolStreamExtractor::EventType::AppendDataModel;
                        result.eventJson = eventJson;
                        outResults.emplace_back(std::move(result));
                    }
                }
            }

            // Build the set of actively streamed binding paths
            std::set<std::string> activeStreamingPaths;
            for (const auto& entry : _streamingEntries) {
                activeStreamingPaths.insert(entry.bindingPath);
            }

            // Parse the complete JSON and dispatch non-streaming leaf fields
            {
                std::string eventJsonStr = buffer.substr(jsonStart, endPos - jsonStart + 1);
                nlohmann::json fullEvent = nlohmann::json::parse(eventJsonStr, nullptr, false);
                if (!fullEvent.is_discarded() && fullEvent.contains("updateDataModel")) {
                    auto& udm = fullEvent["updateDataModel"];
                    if (udm.contains("value") && udm.contains("surfaceId")) {
                        nlohmann::json value = udm["value"];
                        std::string sid = udm["surfaceId"].get<std::string>();
                        std::string ePath = udm.contains("path")
                            ? udm["path"].get<std::string>() : "/";
                        std::string basePath = (ePath == "/") ? "" : ePath;

                        dispatchLeafFieldEvents(value, sid, basePath,