}
  }

  /**
   * Attempts to remove a single frame from a queue and send it. This prefers to write urgent pongs
   * before less urgent messages and close frames. For example, it's possible that a caller will
   * enqueue messages followed by pongs, but this sends pongs followed by messages. Pongs are always
   * written in the order they were enqueued.
   *

├── fess_label.properties           # Base English labels (fallback)
├── fess_label_[locale].properties  # Language-specific labels (~1,056 lines)
├── fess_message.properties         # Base English messages (fallback)
└── fess_message_[locale].properties # Language-specific messages (~200 lines)
```

### Naming Convention

- **Language only**: `fess_label_en.properties`, `fess_label_ja.properties`

// Continuation Message
// ====================
// Header specification
// --------------------
// Continuation messages contain two headers, as follows:
// https://docs.aws.amazon.com/AmazonS3/latest/API/images/s3select-frame-diagram-cont.png
//
// Payload specification
// ---------------------
// Continuation messages have no payload.
func genContinuationMessage() {
	buf := new(bytes.Buffer)

	buf.WriteByte(13)

                throw new SsoMessageException(
                        messages -> messages.addErrorsFailedToProcessSsoRequest(UserMessages.GLOBAL_PROPERTY_KEY, e.getMessage()),
                        "Failed to process metadata.", e);
            }
        })
                .orElseThrow(() -> new SsoMessageException(
                        messages -> messages.addErrorsFailedToProcessSsoRequest(UserMessages.GLOBAL_PROPERTY_KEY, "Invalid state."),

        final LlmChatRequest request = new LlmChatRequest();
        final List<LlmMessage> messages = new ArrayList<>();
        messages.add(LlmMessage.user("Message 1"));
        messages.add(LlmMessage.assistant("Message 2"));

        request.setMessages(messages);

        assertSame(messages, request.getMessages());
        assertEquals(2, request.getMessages().size());
    }

    @Test

@app.post("/messages", response_model=Message)
async def create_message(input_message: str) -> Message:
    return Message(
        input=input_message,
        output=MessageOutput(body=f"Processed: {input_message}"),
    )


client = TestClient(app)


def test_create_message():
    response = client.post("/messages", params={"input_message": "Hello"})

        validate(form, messages -> {}, this::asDetailsHtml);
        verifyToken(this::asDetailsHtml);
        final String id = form.id;
        failureUrlService.getFailureUrl(id).alwaysPresent(entity -> {
            failureUrlService.delete(entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
        });
        return redirect(getClass());

	TargetConsole
	TargetHTTP
	TargetKafka
)

// TargetStats contains statistics for a target.
type TargetStats struct {
	// QueueLength is the queue length if any messages are queued.
	QueueLength int

	// TotalMessages is the total number of messages sent in the lifetime of the target
	TotalMessages int64

	// FailedMessages should log message count that failed to send.
	FailedMessages int64

        void testDeepMessageChaining() {
            TestServerMessageBlock2[] messages = new TestServerMessageBlock2[10];
            for (int i = 0; i < messages.length; i++) {
                messages[i] = new TestServerMessageBlock2(mockConfig);
                if (i > 0) {
                    assertTrue(messages[0].chain(messages[i]));
                }
            }

        verifyCrudMode(form.crudMode, CrudMode.DETAILS, this::asListHtml);
        validate(form, messages -> {}, this::asDetailsHtml);
        verifyToken(this::asDetailsHtml);
        final String id = form.id;
        jobLogService.getJobLog(id).alwaysPresent(entity -> {
            jobLogService.delete(entity);
            saveInfo(messages -> messages.addSuccessCrudDeleteCrudTable(GLOBAL));
        });
        return redirect(getClass());