feat: Support compressed requests in the RPT client

Author: davidkna-sap

.changeset/new-tigers-guess.md

@@ -0,0 +1,6 @@
+---
+'@sap-ai-sdk/rpt': minor
+---
+
+[feat] Add generic HTTP request configuration support.
+The `predictWithSchema()` and `predictWithoutSchema()` methods now accept an optional `customRequest` parameter of type `RptRequestOptions`, allowing configuration of custom HTTP request options such as headers, timeout, and middlewares.

.changeset/true-dolls-say.md

@@ -0,0 +1,8 @@
+---
+'@sap-ai-sdk/rpt': minor
+---
+
+[feat] Add predict request compression support.
+All requests with a body of 1024 bytes or larger will be automatically compressed with `gzip` by default, unless configured otherwise.
+Compression configuration is available via the `requestCompression` property on the `RptClientConfig` object.
+Supported compression algorithms include `gzip`, `brotli`, `deflate`, and `zstd` (requires Node.js v22.15.0+).

packages/rpt/package.json

@@ -40,6 +40,7 @@
     "@sap-ai-sdk/ai-api": "workspace:^",
     "@sap-ai-sdk/core": "workspace:^",
     "@sap-cloud-sdk/connectivity": "^4.4.0",
+    "@sap-cloud-sdk/http-client": "^4.4.0",
     "@sap-cloud-sdk/util": "^4.4.0"
   }
 }

packages/rpt/src/client.ts

@@ -2,8 +2,10 @@ import {
   getFoundationModelDeploymentId,
   getResourceGroup
 } from '@sap-ai-sdk/ai-api/internal.js';
-import { RptApi } from './internal.js';
-import { type DataSchema, type PredictionData } from './types.js';
+import { createLogger } from '@sap-cloud-sdk/util';
+import { executeRequest } from '@sap-ai-sdk/core';
+import { compressRequest } from './vendor/index.js';
+import type { DataSchema, PredictionData, RptRequestOptions } from './types.js';
 import type {
   PredictRequestPayload,
   PredictResponsePayload
@@ -12,6 +14,11 @@ import type { SapRptModel } from '@sap-ai-sdk/core/internal.js';
 import type { ModelDeployment } from '@sap-ai-sdk/ai-api';
 import type { HttpDestinationOrFetchOptions } from '@sap-cloud-sdk/connectivity';
 
+const logger = createLogger({
+  package: 'rpt',
+  messageContext: 'RptClient'
+});
+
 /**
  * Representation of an RPT client to make predictions.
  * @experimental This class is experimental and may change at any time without prior notice.
@@ -32,36 +39,42 @@ export class RptClient {
    * Prefer using this method when the data schema is known.
    * @param dataSchema - Prediction data follows this schema. When using TypeScript, the data schema type is used to infer the types of the prediction data. In that case, the data schema must be provided as a constant (`as const`).
    * @param predictionData - Data to base prediction on.
+   * @param customRequest - Custom request options.
    * @returns Prediction response.
    */
   async predictWithSchema<const T extends DataSchema>(
     dataSchema: T,
-    predictionData: PredictionData<T>
+    predictionData: PredictionData<T>,
+    customRequest: RptRequestOptions = {}
   ): Promise<PredictResponsePayload> {
-    return this.executePrediction(predictionData, dataSchema);
+    return this.executePrediction(predictionData, dataSchema, customRequest);
   }
 
   /**
    * Predict based on prediction data with data schema inferred.
    * Prefer using `predictWithSchema` when the data schema is known.
    * @param predictionData - Data to base prediction on.
+   * @param customRequest - Custom request options.
    * @returns Prediction response.
    */
   async predictWithoutSchema(
-    predictionData: PredictionData<DataSchema>
+    predictionData: PredictionData<DataSchema>,
+    customRequest: RptRequestOptions = {}
   ): Promise<PredictResponsePayload> {
-    return this.executePrediction(predictionData);
+    return this.executePrediction(predictionData, undefined, customRequest);
   }
 
   /**
    * Predict based on data schema and prediction data.
    * @param predictionData - Data to base prediction on.
    * @param dataSchema - Prediction data follows this schema.
+   * @param customRequestAll - Custom request options.
    * @returns Prediction response.
    */
   private async executePrediction<const T extends DataSchema>(
     predictionData: PredictionData<T>,
-    dataSchema?: T
+    dataSchema?: T,
+    customRequestAll: RptRequestOptions = {}
   ): Promise<PredictResponsePayload> {
     const deploymentId = await getFoundationModelDeploymentId(
       this.modelDeployment,
@@ -83,9 +96,32 @@ export class RptClient {
       ...predictionData
     } satisfies PredictRequestPayload;
 
-    return RptApi.predict(body)
-      .setBasePath(`/inference/deployments/${deploymentId}`)
-      .addCustomHeaders({ 'ai-resource-group': resourceGroup || 'default' })
-      .execute(this.destination);
+    const { requestCompression, ...customRequest } = customRequestAll;
+
+    if (requestCompression?.mode !== false) {
+      if (customRequest.middlewares) {
+        logger.warn(
+          'Custom middlewares are not supported when request compression is enabled. ' +
+            'The compression middleware will not be applied. ' +
+            'Please disable request compression in RptRequestOptions to avoid this warning (`requestCompression.mode = false`).'
+        );
+      }
+      customRequest.middlewares = [compressRequest(requestCompression)];
+    }
+
+    const response = await executeRequest(
+      {
+        url: `/inference/deployments/${deploymentId}/predict`,
+        resourceGroup: resourceGroup || 'default'
+      },
+      body,
+      customRequest,
+      this.destination
+    );
+
+    if (response.data) {
+      return response.data;
+    }
+    throw new Error('No data received from RPT prediction request');
   }
 }

packages/rpt/src/index.ts

@@ -1,7 +1,11 @@
 export * from './client.js';
-export type { PredictionData, DateString } from './types.js';
+export type { PredictionData, DateString, RptRequestOptions } from './types.js';
 export type {
   PredictResponseMetadata,
   PredictResponsePayload,
   PredictResponseStatus
 } from './client/rpt/schema/index.js';
+export type {
+  RequestCompressionMiddlewareOptions,
+  RequestCompressionAlgorithm
+} from './vendor/index.js';

packages/rpt/src/types.ts

@@ -1,5 +1,15 @@
 import type { Xor } from '@sap-cloud-sdk/util';
 import type { ColumnType, SchemaFieldConfig } from './client/rpt/index.js';
+import type { CustomRequestConfig } from '@sap-cloud-sdk/http-client';
+import type {
+  RequestCompressionMiddlewareOptions,
+  RequestCompressionAlgorithm
+} from './vendor/index.js';
+
+export type {
+  RequestCompressionMiddlewareOptions,
+  RequestCompressionAlgorithm
+} from './vendor/index.js';
 
 /**
  * Represents a string literal type that includes all column names from the data schema.
@@ -121,3 +131,19 @@ export type PredictionData<T extends DataSchema> = {
     columns: ColType<T>;
   }
 >;
+
+/**
+ * Custom options for how requests are made to the RPT service endpoint are performed.
+ * @template C - The compression algorithm type.
+ */
+export interface RptRequestOptions<
+  C extends RequestCompressionAlgorithm = RequestCompressionAlgorithm
+> extends CustomRequestConfig {
+  /**
+   * Options to configure request compression.
+   * @remarks This option does not affect responses, only requests.
+   * Prediction requests with parquet will not be compressed even if the option is set, as they are already in a compressed binary format.
+   * Compression will be disabled if custom middlewares are provided in the destination or fetch options.
+   */
+  requestCompression?: RequestCompressionMiddlewareOptions<C>;
+}