*
     * @return true if LLM chat is configured and available, false otherwise
     */
    public boolean available() {
        final String llmType = getLlmType();
        if (Constants.NONE.equals(llmType)) {
            if (logger.isTraceEnabled()) {
                logger.trace("[LLM] LLM not available. llmType=none");
            }
            return false;
        }
        if (!isRagChatEnabled()) {

     * @param request the request being processed
     * @param response the intermediate response
     * @return true if more responses are expected, false otherwise
     */
    protected <T extends Response> boolean handleIntermediate(final Request request, final T response) {
        return false;
    }

    /**
     * Gets the response timeout for a specific request.
     *
     * @param request the request to get timeout for

    assert state["/async_raise"] == "asyncgen raise finalized"
    assert "/async_raise" in errors
    errors.clear()


def test_async_raise_server_error():
    client = TestClient(app, raise_server_exceptions=False)
    response = client.get("/async_raise")
    assert response.status_code == 500, response.text
    assert state["/async_raise"] == "asyncgen raise finalized"
    assert "/async_raise" in errors
    errors.clear()

        }

        @Test
        @DisplayName("allowChain should return false when config disallows compound")
        void testAllowChainDisallowed() {
            TestServerMessageBlock2Request nextRequest = new TestServerMessageBlock2Request(mockConfig);
            when(mockConfig.isAllowCompound(anyString())).thenReturn(false);

            boolean result = testRequest.allowChain(nextRequest);

     */
    private static class TestReadingConverter implements ReadingConverter {

        private boolean initialized = false;
        private int initCount = 0;
        private boolean japaneseMode = false;

        public void setJapaneseMode(boolean japaneseMode) {
            this.japaneseMode = japaneseMode;
        }

        public boolean isInitialized() {

     */
    private static boolean objectsEqual(Object o1, Object o2) {
        if (o1 == null && o2 == null) {
            return true;
        }
        if (o1 == null || o2 == null) {
            return false; // as they are not both null
        }
        return o1.equals(o2);
    }

    // ----------------------------------------------------------------------------
    /**

                    if (log.isDebugEnabled()) {
                        log.debug("Closing session after timeout " + ssn);
                    }
                    ssn.logoff(false, false);
                }
            }
        }
        final SmbSessionImpl ssn = new SmbSessionImpl(tf, targetHost, targetDomain, this);
        if (log.isDebugEnabled()) {

// that it was uploaded using some form of server-side-encryption
// and the S3 multipart API.
func IsMultiPart(metadata map[string]string) bool {
	if _, ok := metadata[MetaMultipart]; ok {
		return true
	}
	return false
}

// RemoveSensitiveEntries removes confidential encryption
// information - e.g. the SSE-C key - from the metadata map.
// It has the same semantics as RemoveSensitiveHeaders.

		<div class="card">
			<div class="card-body login-card-body">
				<p class="login-box-msg">
					<la:message key="labels.login" />
				</p>
				<%-- Message --%>
				<div>
					<la:info id="msg" message="false">
						<div class="alert alert-info">${msg}</div>
					</la:info>
					<la:errors />
				</div>
				<la:form styleId="login" method="post">
					<div class="input-group mb-3">
						<c:set var="ph_username">

          contentLength: Long,
          done: Boolean,
        ) {
          if (done) {
            println("completed")
          } else {
            if (firstUpdate) {
              firstUpdate = false
              if (contentLength == -1L) {
                println("content-length: unknown")
              } else {
                println("content-length: $contentLength")
              }
            }