kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/vendor/kreuzberg/src/api/handlers.rs

@@ -9,10 +9,7 @@ use crate::{batch_extract_bytes, cache, extract_bytes};
 
 use super::{
     error::ApiError,
-    types::{
-        ApiState, CacheClearResponse, CacheStatsResponse, EmbedRequest, EmbedResponse, ExtractResponse, HealthResponse,
-        InfoResponse,
-    },
+    types::{ApiState, CacheClearResponse, CacheStatsResponse, ExtractResponse, HealthResponse, InfoResponse},
 };
 
 /// Extract endpoint handler.
@@ -27,24 +24,15 @@ use super::{
 ///
 /// # Size Limits
 ///
-/// Request body size limits are enforced at the router layer via `DefaultBodyLimit` and `RequestBodyLimitLayer`.
+/// Request body size limits are enforced at the router layer via `RequestBodyLimitLayer`.
 /// Default limits:
 /// - Total request body: 100 MB (all files + form data combined)
-/// - Individual multipart fields: 100 MB (controlled by Axum's `DefaultBodyLimit`)
+/// - Individual multipart fields: Controlled by Axum's default multipart limits
 ///
-/// Limits can be configured via environment variables or programmatically when creating the router.
 /// If a request exceeds the size limit, it will be rejected with HTTP 413 (Payload Too Large).
 ///
 /// The server's default config (loaded from kreuzberg.toml/yaml/json via discovery)
 /// is used as the base, and any per-request config overrides those defaults.
-#[cfg_attr(
-    feature = "otel",
-    tracing::instrument(
-        name = "api.extract",
-        skip(state, multipart),
-        fields(files_count = tracing::field::Empty)
-    )
-)]
 pub async fn extract_handler(
     State(state): State<ApiState>,
     mut multipart: Multipart,
@@ -95,9 +83,6 @@ pub async fn extract_handler(
         )));
     }
 
-    #[cfg(feature = "otel")]
-    tracing::Span::current().record("files_count", files.len());
-
     if files.len() == 1 {
         let (data, mime_type, _file_name) = files
             .into_iter()
@@ -109,14 +94,18 @@ pub async fn extract_handler(
 
     let files_data: Vec<(Vec<u8>, String)> = files.into_iter().map(|(data, mime, _name)| (data, mime)).collect();
 
-    let results = batch_extract_bytes(files_data, &config).await?;
+    let file_refs: Vec<(&[u8], &str)> = files_data
+        .iter()
+        .map(|(data, mime)| (data.as_slice(), mime.as_str()))
+        .collect();
+
+    let results = batch_extract_bytes(file_refs, &config).await?;
     Ok(Json(results))
 }
 
 /// Health check endpoint handler.
 ///
 /// GET /health
-#[cfg_attr(feature = "otel", tracing::instrument(name = "api.health"))]
 pub async fn health_handler() -> Json<HealthResponse> {
     Json(HealthResponse {
         status: "healthy".to_string(),
@@ -127,7 +116,6 @@ pub async fn health_handler() -> Json<HealthResponse> {
 /// Server info endpoint handler.
 ///
 /// GET /info
-#[cfg_attr(feature = "otel", tracing::instrument(name = "api.info"))]
 pub async fn info_handler() -> Json<InfoResponse> {
     Json(InfoResponse {
         version: env!("CARGO_PKG_VERSION").to_string(),
@@ -145,7 +133,6 @@ pub async fn info_handler() -> Json<InfoResponse> {
 /// - Current directory cannot be determined
 /// - Cache directory path contains non-UTF8 characters
 /// - Cache metadata retrieval fails
-#[cfg_attr(feature = "otel", tracing::instrument(name = "api.cache_stats"))]
 pub async fn cache_stats_handler() -> Result<Json<CacheStatsResponse>, ApiError> {
     let cache_dir = std::env::current_dir()
         .map_err(|e| {
@@ -185,7 +172,6 @@ pub async fn cache_stats_handler() -> Result<Json<CacheStatsResponse>, ApiError>
 /// - Current directory cannot be determined
 /// - Cache directory path contains non-UTF8 characters
 /// - Cache clearing operation fails
-#[cfg_attr(feature = "otel", tracing::instrument(name = "api.cache_clear"))]
 pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError> {
     let cache_dir = std::env::current_dir()
         .map_err(|e| {
@@ -211,110 +197,3 @@ pub async fn cache_clear_handler() -> Result<Json<CacheClearResponse>, ApiError>
         freed_mb,
     }))
 }
-
-/// Embedding endpoint handler.
-///
-/// POST /embed
-///
-/// Accepts JSON body with:
-/// - `texts`: Array of strings to generate embeddings for
-/// - `config` (optional): Embedding configuration (model, batch size, cache_dir)
-///
-/// Returns embeddings for each input text.
-///
-/// # Errors
-///
-/// Returns `ApiError::Internal` if:
-/// - Embeddings feature is not enabled
-/// - ONNX Runtime is not available
-/// - Model initialization fails
-/// - Embedding generation fails
-#[cfg(feature = "embeddings")]
-#[cfg_attr(
-    feature = "otel",
-    tracing::instrument(
-        name = "api.embed",
-        skip(request),
-        fields(
-            texts_count = request.texts.len(),
-            model = tracing::field::Empty
-        )
-    )
-)]
-pub async fn embed_handler(Json(request): Json<EmbedRequest>) -> Result<Json<EmbedResponse>, ApiError> {
-    use crate::types::{Chunk, ChunkMetadata};
-
-    if request.texts.is_empty() {
-        return Err(ApiError::validation(crate::error::KreuzbergError::validation(
-            "No texts provided for embedding generation",
-        )));
-    }
-
-    // Use default config if none provided
-    let config = request.config.unwrap_or_default();
-
-    // Create chunks from input texts
-    let mut chunks: Vec<Chunk> = request
-        .texts
-        .iter()
-        .enumerate()
-        .map(|(idx, text)| Chunk {
-            content: text.clone(),
-            embedding: None,
-            metadata: ChunkMetadata {
-                byte_start: 0,
-                byte_end: text.len(),
-                token_count: None,
-                chunk_index: idx,
-                total_chunks: request.texts.len(),
-                first_page: None,
-                last_page: None,
-            },
-        })
-        .collect();
-
-    // Generate embeddings
-    crate::embeddings::generate_embeddings_for_chunks(&mut chunks, &config).map_err(ApiError::internal)?;
-
-    // Extract embeddings from chunks
-    let embeddings: Vec<Vec<f32>> = chunks
-        .into_iter()
-        .map(|chunk| {
-            chunk.embedding.ok_or_else(|| {
-                ApiError::internal(crate::error::KreuzbergError::Other(
-                    "Failed to generate embedding for text".to_string(),
-                ))
-            })
-        })
-        .collect::<Result<Vec<_>, _>>()?;
-
-    let dimensions = embeddings.first().map(|e| e.len()).unwrap_or(0);
-
-    // Get model name from config
-    let model_name = match &config.model {
-        crate::core::config::EmbeddingModelType::Preset { name } => name.clone(),
-        #[cfg(feature = "embeddings")]
-        crate::core::config::EmbeddingModelType::FastEmbed { model, .. } => model.clone(),
-        crate::core::config::EmbeddingModelType::Custom { .. } => "custom".to_string(),
-    };
-
-    #[cfg(feature = "otel")]
-    tracing::Span::current().record("model", &model_name);
-
-    Ok(Json(EmbedResponse {
-        embeddings,
-        model: model_name,
-        dimensions,
-        count: request.texts.len(),
-    }))
-}
-
-/// Embedding endpoint handler (when embeddings feature is disabled).
-///
-/// Returns an error indicating embeddings feature is not enabled.
-#[cfg(not(feature = "embeddings"))]
-pub async fn embed_handler(Json(_request): Json<EmbedRequest>) -> Result<Json<EmbedResponse>, ApiError> {
-    Err(ApiError::internal(crate::error::KreuzbergError::MissingDependency(
-        "Embeddings feature is not enabled. Rebuild with --features embeddings".to_string(),
-    )))
-}

data/vendor/kreuzberg/src/api/mod.rs

@@ -6,11 +6,8 @@
 //! # Endpoints
 //!
 //! - `POST /extract` - Extract text from uploaded files (multipart form data)
-//! - `POST /embed` - Generate embeddings for text (JSON body with texts array)
 //! - `GET /health` - Health check endpoint
 //! - `GET /info` - Server information
-//! - `GET /cache/stats` - Get cache statistics
-//! - `DELETE /cache/clear` - Clear all cached files
 //!
 //! # Examples
 //!
@@ -65,17 +62,6 @@
 //!
 //! # Server info
 //! curl http://localhost:8000/info
-//!
-//! # Cache statistics
-//! curl http://localhost:8000/cache/stats
-//!
-//! # Clear cache
-//! curl -X DELETE http://localhost:8000/cache/clear
-//!
-//! # Generate embeddings
-//! curl -X POST http://localhost:8000/embed \
-//!      -H "Content-Type: application/json" \
-//!      -d '{"texts":["Hello world","Second text"]}'
 //! ```
 
 mod error;
@@ -85,10 +71,9 @@ mod types;
 
 pub use error::ApiError;
 pub use server::{
-    create_router, create_router_with_limits, create_router_with_limits_and_server_config, load_server_config, serve,
-    serve_default, serve_with_config, serve_with_config_and_limits, serve_with_server_config,
+    create_router, create_router_with_limits, serve, serve_default, serve_with_config, serve_with_config_and_limits,
 };
 pub use types::{
-    ApiSizeLimits, ApiState, CacheClearResponse, CacheStatsResponse, EmbedRequest, EmbedResponse, ErrorResponse,
-    ExtractResponse, HealthResponse, InfoResponse,
+    ApiSizeLimits, ApiState, CacheClearResponse, CacheStatsResponse, ErrorResponse, ExtractResponse, HealthResponse,
+    InfoResponse,
 };

data/vendor/kreuzberg/src/api/server.rs

@@ -1,10 +1,12 @@
 //! API server setup and configuration.
 
-use std::{net::SocketAddr, sync::Arc};
+use std::{
+    net::{IpAddr, SocketAddr},
+    sync::Arc,
+};
 
 use axum::{
     Router,
-    extract::DefaultBodyLimit,
     routing::{delete, get, post},
 };
 use tower_http::{
@@ -13,79 +15,60 @@ use tower_http::{
     trace::TraceLayer,
 };
 
-use crate::{ExtractionConfig, Result, core::ServerConfig};
+use crate::{ExtractionConfig, Result};
 
 use super::{
-    handlers::{
-        cache_clear_handler, cache_stats_handler, embed_handler, extract_handler, health_handler, info_handler,
-    },
+    handlers::{cache_clear_handler, cache_stats_handler, extract_handler, health_handler, info_handler},
     types::{ApiSizeLimits, ApiState},
 };
 
-/// Load ServerConfig with proper precedence order.
-///
-/// This function implements the configuration hierarchy:
-/// 1. File (if provided)
-/// 2. Environment variables (via apply_env_overrides)
-/// 3. Defaults
-///
-/// The config file can be in flat format (server settings at root) or nested format
-/// (server settings under [server] section alongside other configs like [ocr]).
-///
-/// # Arguments
-///
-/// * `config_path` - Optional path to a ServerConfig file (TOML, YAML, or JSON)
-///
-/// # Returns
-///
-/// A configured ServerConfig with proper precedence applied.
-///
-/// # Errors
-///
-/// Returns an error if:
-/// - The config file path is provided but cannot be read
-/// - The config file contains invalid server configuration
-/// - Environment variable overrides contain invalid values
-///
-/// # Examples
-///
-/// ```no_run
-/// use kreuzberg::api::load_server_config;
-/// use std::path::Path;
-///
-/// # fn example() -> kreuzberg::Result<()> {
-/// // Load from file with env overrides
-/// let config = load_server_config(Some(Path::new("server.toml")))?;
-///
-/// // Or use defaults with env overrides
-/// let config = load_server_config(None)?;
-/// # Ok(())
-/// # }
-/// ```
-pub fn load_server_config(config_path: Option<&std::path::Path>) -> Result<ServerConfig> {
-    let mut config = if let Some(path) = config_path {
-        ServerConfig::from_file(path)?
-    } else {
-        ServerConfig::default()
-    };
-
-    // Apply environment variable overrides with proper logging
-    config.apply_env_overrides()?;
-
-    tracing::info!(
-        "Server configuration loaded: host={}, port={}, request_body_limit={} MB, multipart_field_limit={} MB, CORS={}",
-        config.host,
-        config.port,
-        config.max_request_body_mb(),
-        config.max_multipart_field_mb(),
-        if config.cors_allows_all() {
-            "allow all origins".to_string()
-        } else {
-            format!("{} specific origins", config.cors_origins.len())
+/// Parse size limits from environment variables.
+///
+/// Reads `KREUZBERG_MAX_UPLOAD_SIZE_MB` to configure upload size limits.
+/// Falls back to default (100 MB) if not set or invalid.
+fn parse_size_limits_from_env() -> ApiSizeLimits {
+    match std::env::var("KREUZBERG_MAX_UPLOAD_SIZE_MB") {
+        Ok(value) => match value.parse::<usize>() {
+            Ok(mb) if mb > 0 => {
+                tracing::info!(
+                    "Upload size limit configured from environment: {} MB ({} bytes)",
+                    mb,
+                    mb * 1024 * 1024
+                );
+                ApiSizeLimits::from_mb(mb, mb)
+            }
+            Ok(_) => {
+                tracing::warn!("Invalid KREUZBERG_MAX_UPLOAD_SIZE_MB value (must be > 0), using default 100 MB");
+                let limits = ApiSizeLimits::default();
+                tracing::info!(
+                    "Upload size limit: 100 MB (default, {} bytes)",
+                    limits.max_request_body_bytes
+                );
+                limits
+            }
+            Err(e) => {
+                tracing::warn!(
+                    "Failed to parse KREUZBERG_MAX_UPLOAD_SIZE_MB='{}': {}, using default 100 MB",
+                    value,
+                    e
+                );
+                let limits = ApiSizeLimits::default();
+                tracing::info!(
+                    "Upload size limit: 100 MB (default, {} bytes)",
+                    limits.max_request_body_bytes
+                );
+                limits
+            }
+        },
+        Err(_) => {
+            let limits = ApiSizeLimits::default();
+            tracing::info!(
+                "Upload size limit: 100 MB (default, {} bytes)",
+                limits.max_request_body_bytes
+            );
+            limits
         }
-    );
-
-    Ok(config)
+    }
 }
 
 /// Create the API router with all routes configured.
@@ -148,58 +131,15 @@ pub fn create_router(config: ExtractionConfig) -> Router {
 /// # }
 /// ```
 pub fn create_router_with_limits(config: ExtractionConfig, limits: ApiSizeLimits) -> Router {
-    create_router_with_limits_and_server_config(config, limits, ServerConfig::default())
-}
-
-/// Create the API router with custom size limits and server configuration.
-///
-/// This function provides full control over request limits, CORS, and server settings via ServerConfig.
-///
-/// # Arguments
-///
-/// * `config` - Default extraction configuration. Per-request configs override these defaults.
-/// * `limits` - Size limits for request bodies and multipart uploads.
-/// * `server_config` - Server configuration including host, port, and CORS settings.
-///
-/// # Examples
-///
-/// ```no_run
-/// use kreuzberg::{ExtractionConfig, api::create_router_with_limits, core::ServerConfig};
-///
-/// # #[tokio::main]
-/// # async fn main() -> kreuzberg::Result<()> {
-/// let extraction_config = ExtractionConfig::default();
-/// let mut server_config = ServerConfig::default();
-/// server_config.cors_origins = vec!["https://example.com".to_string()];
-/// let router = create_router_with_limits_and_server_config(
-///     extraction_config,
-///     Default::default(),
-///     server_config
-/// );
-/// # Ok(())
-/// # }
-/// ```
-pub fn create_router_with_limits_and_server_config(
-    config: ExtractionConfig,
-    limits: ApiSizeLimits,
-    server_config: ServerConfig,
-) -> Router {
     let state = ApiState {
         default_config: Arc::new(config),
     };
 
-    // CORS configuration based on ServerConfig
-    let cors_layer = if server_config.cors_allows_all() {
-        tracing::warn!(
-            "CORS configured to allow all origins (default). This permits CSRF attacks. \
-             For production, set KREUZBERG_CORS_ORIGINS environment variable to comma-separated \
-             list of allowed origins (e.g., 'https://app.example.com,https://api.example.com')"
-        );
-        CorsLayer::new().allow_origin(Any).allow_methods(Any).allow_headers(Any)
-    } else {
-        let origins: Vec<_> = server_config
-            .cors_origins
-            .iter()
+    // SECURITY WARNING: The default allows all origins for development convenience,
+    let cors_layer = if let Ok(origins_str) = std::env::var("KREUZBERG_CORS_ORIGINS") {
+        let origins: Vec<_> = origins_str
+            .split(',')
+            .filter(|s| !s.trim().is_empty())
             .filter_map(|s| s.trim().parse::<axum::http::HeaderValue>().ok())
             .collect();
 
@@ -211,21 +151,26 @@ pub fn create_router_with_limits_and_server_config(
                 .allow_headers(Any)
         } else {
             tracing::warn!(
-                "CORS origins configured but empty/invalid - falling back to permissive CORS. \
+                "KREUZBERG_CORS_ORIGINS set but empty/invalid - falling back to permissive CORS. \
                  This allows CSRF attacks. Set explicit origins for production."
             );
             CorsLayer::new().allow_origin(Any).allow_methods(Any).allow_headers(Any)
         }
+    } else {
+        tracing::warn!(
+            "CORS configured to allow all origins (default). This permits CSRF attacks. \
+             For production, set KREUZBERG_CORS_ORIGINS environment variable to comma-separated \
+             list of allowed origins (e.g., 'https://app.example.com,https://api.example.com')"
+        );
+        CorsLayer::new().allow_origin(Any).allow_methods(Any).allow_headers(Any)
     };
 
     Router::new()
         .route("/extract", post(extract_handler))
-        .route("/embed", post(embed_handler))
         .route("/health", get(health_handler))
         .route("/info", get(info_handler))
         .route("/cache/stats", get(cache_stats_handler))
         .route("/cache/clear", delete(cache_clear_handler))
-        .layer(DefaultBodyLimit::max(limits.max_request_body_bytes))
         .layer(RequestBodyLimitLayer::new(limits.max_request_body_bytes))
         .layer(cors_layer)
         .layer(TraceLayer::new_for_http())
@@ -278,18 +223,13 @@ pub fn create_router_with_limits_and_server_config(
 /// # Production: set to comma-separated list of allowed origins
 /// export KREUZBERG_CORS_ORIGINS="https://app.example.com,https://api.example.com"
 ///
-/// # Upload size limits (default: 100 MB)
-/// # Modern approach (in bytes):
-/// export KREUZBERG_MAX_REQUEST_BODY_BYTES=104857600       # 100 MB
-/// export KREUZBERG_MAX_MULTIPART_FIELD_BYTES=104857600    # 100 MB per file
-///
-/// # Legacy approach (in MB, applies to both limits):
-/// export KREUZBERG_MAX_UPLOAD_SIZE_MB=100  # 100 MB
+/// # Upload size limit (default: 100 MB)
+/// export KREUZBERG_MAX_UPLOAD_SIZE_MB=200
 ///
 /// python -m kreuzberg.api
 /// ```
 pub async fn serve(host: impl AsRef<str>, port: u16) -> Result<()> {
-    let extraction_config = match ExtractionConfig::discover()? {
+    let config = match ExtractionConfig::discover()? {
         Some(config) => {
             tracing::info!("Loaded extraction config from discovered file");
             config
@@ -300,13 +240,9 @@ pub async fn serve(host: impl AsRef<str>, port: u16) -> Result<()> {
         }
     };
 
-    let server_config = load_server_config(None)?;
-    let limits = ApiSizeLimits::new(
-        server_config.max_request_body_bytes,
-        server_config.max_multipart_field_bytes,
-    );
+    let limits = parse_size_limits_from_env();
 
-    serve_with_config_and_limits(host, port, extraction_config, limits).await
+    serve_with_config_and_limits(host, port, config, limits).await
 }
 
 /// Start the API server with explicit config.
@@ -368,23 +304,13 @@ pub async fn serve_with_config_and_limits(
     config: ExtractionConfig,
     limits: ApiSizeLimits,
 ) -> Result<()> {
-    use std::net::IpAddr;
-
     let ip: IpAddr = host
         .as_ref()
         .parse()
         .map_err(|e| crate::error::KreuzbergError::validation(format!("Invalid host address: {}", e)))?;
 
-    let server_config = ServerConfig {
-        host: host.as_ref().to_string(),
-        port,
-        max_request_body_bytes: limits.max_request_body_bytes,
-        max_multipart_field_bytes: limits.max_multipart_field_bytes,
-        ..Default::default()
-    };
-
     let addr = SocketAddr::new(ip, port);
-    let app = create_router_with_limits_and_server_config(config, limits, server_config);
+    let app = create_router_with_limits(config, limits);
 
     tracing::info!("Starting Kreuzberg API server on http://{}:{}", ip, port);
 
@@ -399,70 +325,6 @@ pub async fn serve_with_config_and_limits(
     Ok(())
 }
 
-/// Start the API server with explicit extraction config and server config.
-///
-/// This function accepts a fully-configured ServerConfig, including CORS origins,
-/// size limits, host, and port. It respects all ServerConfig fields without
-/// re-parsing environment variables, making it ideal for CLI usage where
-/// configuration precedence has already been applied.
-///
-/// # Arguments
-///
-/// * `extraction_config` - Default extraction configuration for all requests
-/// * `server_config` - Server configuration including host, port, CORS, and size limits
-///
-/// # Examples
-///
-/// ```no_run
-/// use kreuzberg::{ExtractionConfig, api::serve_with_server_config, core::ServerConfig};
-///
-/// #[tokio::main]
-/// async fn main() -> kreuzberg::Result<()> {
-///     let extraction_config = ExtractionConfig::default();
-///     let mut server_config = ServerConfig::default();
-///     server_config.host = "0.0.0.0".to_string();
-///     server_config.port = 3000;
-///     server_config.cors_origins = vec!["https://example.com".to_string()];
-///
-///     serve_with_server_config(extraction_config, server_config).await?;
-///     Ok(())
-/// }
-/// ```
-pub async fn serve_with_server_config(extraction_config: ExtractionConfig, server_config: ServerConfig) -> Result<()> {
-    use std::net::IpAddr;
-
-    let ip: IpAddr = server_config
-        .host
-        .parse()
-        .map_err(|e| crate::error::KreuzbergError::validation(format!("Invalid host address: {}", e)))?;
-
-    let limits = ApiSizeLimits::new(
-        server_config.max_request_body_bytes,
-        server_config.max_multipart_field_bytes,
-    );
-
-    let addr = SocketAddr::new(ip, server_config.port);
-    let app = create_router_with_limits_and_server_config(extraction_config, limits, server_config.clone());
-
-    tracing::info!(
-        "Starting Kreuzberg API server on http://{}:{} (request_body_limit={} MB, multipart_field_limit={} MB)",
-        ip,
-        server_config.port,
-        server_config.max_request_body_mb(),
-        server_config.max_multipart_field_mb()
-    );
-
-    let listener = tokio::net::TcpListener::bind(addr)
-        .await
-        .map_err(crate::error::KreuzbergError::Io)?;
-
-    axum::serve(listener, app)
-        .await
-        .map_err(|e| crate::error::KreuzbergError::Other(e.to_string()))?;
-
-    Ok(())
-}
-
 /// Start the API server with default host and port.
 ///
 /// Defaults: host = "127.0.0.1", port = 8000
@@ -473,7 +335,6 @@ pub async fn serve_default() -> Result<()> {
 }
 
 #[cfg(test)]
-#[allow(unsafe_code)]
 mod tests {
     use super::*;
 
@@ -489,30 +350,4 @@ mod tests {
         let router = create_router(config);
         assert!(size_of_val(&router) > 0);
     }
-
-    #[test]
-    fn test_create_router_with_limits() {
-        let config = ExtractionConfig::default();
-        let limits = ApiSizeLimits::from_mb(50, 50);
-        let _router = create_router_with_limits(config, limits);
-    }
-
-    #[test]
-    fn test_create_router_with_server_config() {
-        let extraction_config = ExtractionConfig::default();
-        let limits = ApiSizeLimits::from_mb(100, 100);
-        let server_config = ServerConfig::default();
-        let _router = create_router_with_limits_and_server_config(extraction_config, limits, server_config);
-    }
-
-    #[test]
-    fn test_server_config_cors_handling() {
-        let extraction_config = ExtractionConfig::default();
-        let limits = ApiSizeLimits::default();
-        let server_config = ServerConfig {
-            cors_origins: vec!["https://example.com".to_string()],
-            ..Default::default()
-        };
-        let _router = create_router_with_limits_and_server_config(extraction_config, limits, server_config);
-    }
 }