final WebAuthentication webAuth = getWebAuthentication(body).map(entity -> {
            try {
                webAuthService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

        } catch (final Exception e) {
            logger.warn("Failed to store crawling information: sessionId={}", options.sessionId, e);
        }

        try {
            return crawler.doCrawl(options);
        } finally {
            try {
                crawlingInfoHelper.store(options.sessionId, false);
            } catch (final Exception e) {

            try {
                downloadObject(getObjectName(pi.getPath(), pi.getName()), out);
            } catch (final StorageException e) {
                logger.warn("Failed to download {}", id, e);
                throwValidationErrorApi(messages -> messages.addErrorsStorageFileDownloadFailure(GLOBAL, pi.getName()));
            }
        });
    }

                            logger.warn("  " + unsafePlugin.getId());
                        }
                        logger.warn("");
                        logger.warn("Enable verbose output (-X) to see precisely which goals are not marked as"
                                + " thread-safe.");
                    }
                    logger.warn(MultilineMessageHelper.separatorLine());
                }

        final FileConfig fileConfig = getFileConfig(body).map(entity -> {
            try {
                fileConfigService.store(entity);
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
            }
            return entity;

        try {
            urlFilterService.delete(sessionId);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlFilter: sessionId={}", sessionId, e);
        }
        try {
            urlQueueService.delete(sessionId);
        } catch (final Exception e) {
            logger.warn("Failed to delete UrlQueue: sessionId={}", sessionId, e);
        }
        try {

            // LlmException from streamChatEnhanced already sent onError via callback - avoid double-send
            logger.warn("LLM error during stream request. sessionId={}, errorCode={}, message={}", sessionId, e.getErrorCode(),
                    e.getMessage(), e);
        } catch (final Exception e) {
            logger.warn("[RAG] Failed to process stream request. sessionId={}, message={}", sessionId, e.getMessage(), e);

            });
            return null;
        });
        try {
            roleService.store(entity);
        } catch (final Exception e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)));
        }

                keyStore.setEntry("smb.session." + sessionId, keyEntry, protection);
            } catch (Exception e) {
                log.warn("Failed to store key in KeyStore: {}", e.getMessage());
            }
        }

        log.debug("Stored session key for session: {}", sessionId);
    }

    /**
     * Retrieve a session key
     *

        scheduledJobService.getScheduledJob(id).ifPresent(entity -> {
            try {
                entity.stop();
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationErrorApi(messages -> {
                    messages.addErrorsFailedToStopJob(GLOBAL, entity.getName());
                });
            }