gremlin 4.0.0-beta.2 → 4.0.0-beta.3

package/build/esm/driver/driver-remote-connection.js

@@ -27,15 +27,26 @@ import Client from './client.js';
  * Represents the default `RemoteConnection` implementation.
  */
 export default class DriverRemoteConnection extends RemoteConnection {
+    // Exposed as package-internal for Transaction to submit begin/commit/rollback.
+    // Not part of the public API contract.
     _client;
+    _transactionId;
     /**
      * Creates a new instance of {@link DriverRemoteConnection}.
      * @param {String} url The resource uri.
      * @param {ConnectionOptions} [options] The connection options.
+     * @param {String} [transactionId] Optional transaction ID to attach to all requests.
      */
-    constructor(url, options = {}) {
+    constructor(url, options = {}, transactionId) {
         super(url, options);
         this._client = new Client(url, options);
+        this._transactionId = transactionId;
+    }
+    /**
+     * Returns the transaction ID if this connection is bound to a transaction, undefined otherwise.
+     */
+    get transactionId() {
+        return this._transactionId;
     }
     /** @override */
     open() {
@@ -47,14 +58,18 @@ export default class DriverRemoteConnection extends RemoteConnection {
     }
     /** @override */
     submit(gremlinLang) {
-        gremlinLang.addG(this.options.traversalSource || 'g');
+        const { gremlin, requestOptions } = this.#buildRequestArgs(gremlinLang);
+        // Use streaming internally — returns an AsyncGenerator backed RemoteTraversal
+        const generator = this._client.stream(gremlin, null, requestOptions);
+        return Promise.resolve(new RemoteTraversal(generator));
+    }
+    #buildRequestArgs(gremlinLang) {
         let requestOptions = undefined;
         const strategies = gremlinLang.getOptionsStrategies();
         if (strategies.length > 0) {
             requestOptions = {};
             const allowedKeys = [
-                'evaluationTimeout',
-                'scriptEvaluationTimeout',
+                'timeoutMillis',
                 'batchSize',
                 'requestId',
                 'userAgent',
@@ -75,18 +90,15 @@ export default class DriverRemoteConnection extends RemoteConnection {
         if (!('bulkResults' in requestOptions)) {
             requestOptions.bulkResults = true;
         }
-        const params = gremlinLang.getParameters();
-        if (params.size > 0) {
-            requestOptions.params = Object.fromEntries(params);
+        const parametersString = gremlinLang.getParametersAsString();
+        if (parametersString !== '[:]') {
+            requestOptions.parameters = parametersString;
         }
-        return this._client.submit(gremlinLang.getGremlin(), null, requestOptions)
-            .then((result) => new RemoteTraversal(result.toArray()));
-    }
-    commit() {
-        return this._client.submit('g.tx().commit()', null);
-    }
-    rollback() {
-        return this._client.submit('g.tx().rollback()', null);
+        // If this connection is bound to a transaction, attach the transactionId
+        if (this._transactionId) {
+            requestOptions.transactionId = this._transactionId;
+        }
+        return { gremlin: gremlinLang.getGremlin(), requestOptions };
     }
     close() {
         return this._client.close();

package/build/esm/driver/http-request.d.ts

@@ -0,0 +1,28 @@
+import { Buffer } from 'buffer';
+import { RequestMessage } from './request-message.js';
+/**
+ * Represents an HTTP request that is passed through interceptors before being sent to the server.
+ * Interceptors may mutate any field. The {@link serializeBody} method serializes the body to JSON
+ * if it is still a RequestMessage, or returns the existing bytes if already serialized.
+ */
+export declare class HttpRequest {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body: RequestMessage | Buffer | any;
+    constructor(method: string, url: string, headers: Record<string, string>, body: any);
+    /**
+     * Serializes the request body to JSON if it is still a RequestMessage.
+     * If body is already a Buffer, returns it as-is (idempotent).
+     * Sets Content-Type and Content-Length headers on successful serialization.
+     *
+     * @returns The serialized body as a Buffer.
+     * @throws Error if body is neither a RequestMessage nor a Buffer.
+     */
+    serializeBody(): Buffer;
+}
+/**
+ * A request interceptor receives an HttpRequest and mutates it in place.
+ * Interceptors must not return a value.
+ */
+export type RequestInterceptor = (request: HttpRequest) => void | Promise<void>;

package/build/esm/driver/http-request.js

@@ -0,0 +1,60 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+import { Buffer } from 'buffer';
+import { RequestMessage } from './request-message.js';
+/**
+ * Represents an HTTP request that is passed through interceptors before being sent to the server.
+ * Interceptors may mutate any field. The {@link serializeBody} method serializes the body to JSON
+ * if it is still a RequestMessage, or returns the existing bytes if already serialized.
+ */
+export class HttpRequest {
+    url;
+    method;
+    headers;
+    body;
+    constructor(method, url, headers, body) {
+        this.method = method;
+        this.url = url;
+        this.headers = headers;
+        this.body = body;
+    }
+    /**
+     * Serializes the request body to JSON if it is still a RequestMessage.
+     * If body is already a Buffer, returns it as-is (idempotent).
+     * Sets Content-Type and Content-Length headers on successful serialization.
+     *
+     * @returns The serialized body as a Buffer.
+     * @throws Error if body is neither a RequestMessage nor a Buffer.
+     */
+    serializeBody() {
+        if (Buffer.isBuffer(this.body)) {
+            return this.body;
+        }
+        if (this.body instanceof RequestMessage) {
+            // RequestMessage.toJSON() produces the flattened wire object (standard + custom fields).
+            const data = Buffer.from(JSON.stringify(this.body), 'utf-8');
+            this.body = data;
+            this.headers['Content-Type'] = 'application/json';
+            this.headers['Content-Length'] = String(data.length);
+            return data;
+        }
+        const typeName = this.body === null ? 'null' : typeof this.body;
+        throw new Error(`unsupported body type: ${typeName}`);
+    }
+}

package/build/esm/driver/logger.d.ts

@@ -0,0 +1,29 @@
+/** The set of log levels emitted by the driver, ordered from least to most severe. */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * A logger object with one method per {@link LogLevel}. This shape is compatible with the
+ * global `console` as well as common logging libraries.
+ */
+export interface LoggerObject {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+/**
+ * A logger callback that receives the level alongside the message and any extra arguments.
+ */
+export type LoggerCallback = (level: LogLevel, message: string, ...args: any[]) => void;
+/**
+ * The `logger` connection option. It may be either a {@link LoggerObject} (e.g. the global
+ * `console`) or a {@link LoggerCallback}. Logging is disabled when no logger is provided.
+ */
+export type Logger = LoggerObject | LoggerCallback;
+/**
+ * Normalizes the user-supplied {@link Logger} option into a single callback. When no logger is
+ * provided, a no-op callback is returned so call sites do not need to null-check.
+ *
+ * @param {Logger} [logger] The user-supplied logger option.
+ * @returns {LoggerCallback} A callback that dispatches to the configured logger.
+ */
+export declare function normalizeLogger(logger?: Logger): LoggerCallback;

package/build/esm/driver/logger.js

@@ -0,0 +1,42 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+/**
+ * Normalizes the user-supplied {@link Logger} option into a single callback. When no logger is
+ * provided, a no-op callback is returned so call sites do not need to null-check.
+ *
+ * @param {Logger} [logger] The user-supplied logger option.
+ * @returns {LoggerCallback} A callback that dispatches to the configured logger.
+ */
+export function normalizeLogger(logger) {
+    if (logger === undefined || logger === null) {
+        return () => { };
+    }
+    if (typeof logger === 'function') {
+        return logger;
+    }
+    if (typeof logger === 'object') {
+        return (level, message, ...args) => {
+            const fn = logger[level];
+            if (typeof fn === 'function') {
+                fn.call(logger, message, ...args);
+            }
+        };
+    }
+    throw new TypeError('logger must be a function, a logger object, or undefined');
+}

package/build/esm/driver/remote-connection.d.ts

@@ -3,23 +3,20 @@
  */
 import GremlinLang from '../process/gremlin-lang.js';
 import { TraversalStrategy } from '../process/traversal-strategy.js';
-import { Traversal, Traverser } from '../process/traversal.js';
+import { Traversal } from '../process/traversal.js';
 import type { ConnectionOptions } from './connection.js';
-export type RemoteConnectionOptions = ConnectionOptions & {
-    session?: string;
-};
 /**
  * Represents an abstraction of a "connection" to a "server" that is capable of processing a traversal and
  * returning results.
  */
 export declare abstract class RemoteConnection {
     url: string;
-    protected readonly options: RemoteConnectionOptions;
+    readonly options: ConnectionOptions;
     /**
      * @param {String} url The resource uri.
-     * @param {RemoteConnectionOptions} [options] The connection options.
+     * @param {ConnectionOptions} [options] The connection options.
      */
-    constructor(url: string, options?: RemoteConnectionOptions);
+    constructor(url: string, options?: ConnectionOptions);
     /**
      * Opens the connection, if its not already opened.
      * @returns {Promise}
@@ -37,17 +34,7 @@ export declare abstract class RemoteConnection {
      */
     abstract submit(gremlinLang: GremlinLang): Promise<RemoteTraversal>;
     /**
-     * Submits a commit operation to the server and closes the connection.
-     * @returns {Promise}
-     */
-    abstract commit(): Promise<void>;
-    /**
-     * Submits a rollback operation to the server and closes the connection.
-     * @returns {Promise}
-     */
-    abstract rollback(): Promise<void>;
-    /**
-     * Closes the connection where open transactions will close according to the features of the graph provider.
+     * Closes the connection and releases any associated resources.
      * @returns {Promise}
      */
     abstract close(): Promise<void>;
@@ -56,9 +43,7 @@ export declare abstract class RemoteConnection {
  * Represents a traversal as a result of a {@link RemoteConnection} submission.
  */
 export declare class RemoteTraversal extends Traversal {
-    results: Traverser<any>[];
-    sideEffects?: any[] | undefined;
-    constructor(results: Traverser<any>[], sideEffects?: any[] | undefined);
+    constructor(source: AsyncGenerator<any>, sideEffects?: any[]);
 }
 export declare class RemoteStrategy extends TraversalStrategy {
     connection: RemoteConnection;

package/build/esm/driver/remote-connection.js

@@ -27,7 +27,7 @@ export class RemoteConnection {
     options;
     /**
      * @param {String} url The resource uri.
-     * @param {RemoteConnectionOptions} [options] The connection options.
+     * @param {ConnectionOptions} [options] The connection options.
      */
     constructor(url, options = {}) {
         this.url = url;
@@ -38,12 +38,9 @@ export class RemoteConnection {
  * Represents a traversal as a result of a {@link RemoteConnection} submission.
  */
 export class RemoteTraversal extends Traversal {
-    results;
-    sideEffects;
-    constructor(results, sideEffects) {
+    constructor(source, sideEffects) {
         super(null, null);
-        this.results = results;
-        this.sideEffects = sideEffects;
+        this._resultsStream = source;
     }
 }
 export class RemoteStrategy extends TraversalStrategy {
@@ -58,12 +55,12 @@ export class RemoteStrategy extends TraversalStrategy {
     }
     /** @override */
     apply(traversal) {
-        if (traversal.results) {
+        if (traversal._resultsStream) {
             return Promise.resolve();
         }
         return this.connection.submit(traversal.getGremlinLang()).then(function (remoteTraversal) {
             traversal.sideEffects = remoteTraversal.sideEffects;
-            traversal.results = remoteTraversal.results;
+            traversal._resultsStream = remoteTraversal._resultsStream;
         });
     }
 }

package/build/esm/driver/request-message.d.ts

@@ -4,21 +4,32 @@
 export declare class RequestMessage {
     private gremlin;
     private language;
-    private timeoutMs?;
-    private bindings?;
+    private timeoutMillis?;
+    private parameters?;
     private g?;
     private materializeProperties?;
     private bulkResults?;
+    private batchSize?;
     private customFields;
     private constructor();
     getGremlin(): string;
     getLanguage(): string;
-    getTimeoutMs(): number | undefined;
-    getBindings(): object | undefined;
+    getTimeoutMillis(): number | undefined;
+    getParameters(): object | undefined;
     getG(): string | undefined;
     getMaterializeProperties(): string | undefined;
     getBulkResults(): boolean | undefined;
+    getBatchSize(): number | undefined;
     getFields(): ReadonlyMap<string, any>;
+    /**
+     * Builds the plain object that represents this message on the wire. Standard fields are
+     * included when set, and custom fields are flattened to the top level. This method is
+     * invoked automatically by {@link JSON.stringify}.
+     *
+     * When a new standard field is added to this class, it should be added here as well so that
+     * it is included in the serialized request body.
+     */
+    toJSON(): Record<string, any>;
     static build(gremlin: string): Builder;
 }
 /**
@@ -26,21 +37,40 @@ export declare class RequestMessage {
  */
 export declare class Builder {
     private readonly gremlin;
-    private readonly bindings;
+    private readonly parameters;
+    private parametersString?;
     language: string;
-    timeoutMs?: number;
+    timeoutMillis?: number;
     g?: string;
     materializeProperties?: string;
     bulkResults?: boolean;
+    batchSize?: number;
     additionalFields: Map<string, any>;
     constructor(gremlin: string);
     addLanguage(language: string): Builder;
-    addBinding(key: string, value: any): Builder;
-    addBindings(otherBindings: object): Builder;
+    /**
+     * Adds a single query parameter. The accumulated parameters map is converted to a gremlin-lang
+     * map literal string when the message is created.
+     * Cannot be mixed with {@link addParametersString}.
+     */
+    addParameter(key: string, value: any): Builder;
+    /**
+     * Merges the provided parameters into the accumulated parameters map. The values are converted to a
+     * gremlin-lang map literal string when the message is created.
+     * Cannot be mixed with {@link addParametersString}.
+     */
+    addParameters(otherParameters: object): Builder;
+    /**
+     * Sets the query parameters as a pre-formatted gremlin-lang map literal string (e.g. `'["x":1,"y":"knows"]'`).
+     * Calling this method replaces any previously set parameters string (last-one-wins).
+     * Cannot be mixed with {@link addParameter} or {@link addParameters}.
+     */
+    addParametersString(parametersString: string): Builder;
     addG(g: string): Builder;
     addMaterializeProperties(materializeProps: string): Builder;
     addTimeoutMillis(timeout: number): Builder;
     addBulkResults(bulking: boolean): Builder;
+    addBatchSize(batchSize: number): Builder;
     addField(key: string, value: any): Builder;
     /**
      * Create the request message given the settings provided to the Builder.

package/build/esm/driver/request-message.js

@@ -16,14 +16,16 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import GremlinLang from '../process/gremlin-lang.js';
 // Token constants
 const Tokens = {
     ARGS_LANGUAGE: 'language',
-    ARGS_BINDINGS: 'bindings',
+    ARGS_PARAMETERS: 'parameters',
     ARGS_G: 'g',
     ARGS_MATERIALIZE_PROPERTIES: 'materializeProperties',
-    TIMEOUT_MS: 'timeoutMs',
+    TIMEOUT_MILLIS: 'timeoutMillis',
     BULK_RESULTS: 'bulkResults',
+    BATCH_SIZE: 'batchSize',
     MATERIALIZE_PROPERTIES_TOKENS: 'tokens',
     MATERIALIZE_PROPERTIES_ALL: 'all'
 };
@@ -33,23 +35,25 @@ const Tokens = {
 export class RequestMessage {
     gremlin;
     language;
-    timeoutMs;
-    bindings;
+    timeoutMillis;
+    parameters;
     g;
     materializeProperties;
     bulkResults;
+    batchSize;
     customFields;
-    constructor(gremlin, language, timeoutMs, bindings, g, materializeProperties, bulkResults, customFields) {
+    constructor(gremlin, language, timeoutMillis, parameters, g, materializeProperties, bulkResults, batchSize, customFields) {
         if (!gremlin) {
             throw new Error('RequestMessage requires gremlin argument');
         }
         this.gremlin = gremlin;
         this.language = language;
-        this.timeoutMs = timeoutMs;
-        this.bindings = bindings;
+        this.timeoutMillis = timeoutMillis;
+        this.parameters = parameters;
         this.g = g;
         this.materializeProperties = materializeProperties;
         this.bulkResults = bulkResults;
+        this.batchSize = batchSize;
         this.customFields = customFields;
     }
     getGremlin() {
@@ -58,11 +62,11 @@ export class RequestMessage {
     getLanguage() {
         return this.language;
     }
-    getTimeoutMs() {
-        return this.timeoutMs;
+    getTimeoutMillis() {
+        return this.timeoutMillis;
     }
-    getBindings() {
-        return this.bindings;
+    getParameters() {
+        return this.parameters;
     }
     getG() {
         return this.g;
@@ -73,9 +77,49 @@ export class RequestMessage {
     getBulkResults() {
         return this.bulkResults;
     }
+    getBatchSize() {
+        return this.batchSize;
+    }
     getFields() {
         return this.customFields;
     }
+    /**
+     * Builds the plain object that represents this message on the wire. Standard fields are
+     * included when set, and custom fields are flattened to the top level. This method is
+     * invoked automatically by {@link JSON.stringify}.
+     *
+     * When a new standard field is added to this class, it should be added here as well so that
+     * it is included in the serialized request body.
+     */
+    toJSON() {
+        const payload = { gremlin: this.gremlin };
+        if (this.language) {
+            payload['language'] = this.language;
+        }
+        if (this.g) {
+            payload['g'] = this.g;
+        }
+        if (this.parameters !== undefined) {
+            payload['parameters'] = this.parameters;
+        }
+        if (this.timeoutMillis !== undefined) {
+            payload['timeoutMillis'] = this.timeoutMillis;
+        }
+        if (this.materializeProperties) {
+            payload['materializeProperties'] = this.materializeProperties;
+        }
+        if (this.bulkResults !== undefined) {
+            payload['bulkResults'] = this.bulkResults;
+        }
+        if (this.batchSize !== undefined) {
+            payload['batchSize'] = this.batchSize;
+        }
+        // Flatten custom/provider fields to the top level
+        this.customFields.forEach((v, k) => {
+            payload[k] = v;
+        });
+        return payload;
+    }
     static build(gremlin) {
         return new Builder(gremlin);
     }
@@ -85,12 +129,14 @@ export class RequestMessage {
  */
 export class Builder {
     gremlin;
-    bindings = {};
+    parameters = {};
+    parametersString;
     language;
-    timeoutMs;
+    timeoutMillis;
     g;
     materializeProperties;
     bulkResults;
+    batchSize;
     additionalFields = new Map();
     constructor(gremlin) {
         this.gremlin = gremlin;
@@ -102,14 +148,39 @@ export class Builder {
         this.language = language;
         return this;
     }
-    addBinding(key, value) {
-        Object.assign(this.bindings, { [key]: value });
+    /**
+     * Adds a single query parameter. The accumulated parameters map is converted to a gremlin-lang
+     * map literal string when the message is created.
+     * Cannot be mixed with {@link addParametersString}.
+     */
+    addParameter(key, value) {
+        if (this.parametersString)
+            throw new Error('Cannot mix addParameter() with addParametersString().');
+        Object.assign(this.parameters, { [key]: value });
         return this;
     }
-    addBindings(otherBindings) {
-        if (!otherBindings)
-            throw new Error('bindings argument cannot be null.');
-        Object.assign(this.bindings, otherBindings);
+    /**
+     * Merges the provided parameters into the accumulated parameters map. The values are converted to a
+     * gremlin-lang map literal string when the message is created.
+     * Cannot be mixed with {@link addParametersString}.
+     */
+    addParameters(otherParameters) {
+        if (!otherParameters)
+            throw new Error('parameters argument cannot be null.');
+        if (this.parametersString)
+            throw new Error('Cannot mix addParameters() with addParametersString().');
+        Object.assign(this.parameters, otherParameters);
+        return this;
+    }
+    /**
+     * Sets the query parameters as a pre-formatted gremlin-lang map literal string (e.g. `'["x":1,"y":"knows"]'`).
+     * Calling this method replaces any previously set parameters string (last-one-wins).
+     * Cannot be mixed with {@link addParameter} or {@link addParameters}.
+     */
+    addParametersString(parametersString) {
+        if (Object.keys(this.parameters).length > 0)
+            throw new Error('Cannot mix addParametersString() with addParameter()/addParameters().');
+        this.parametersString = parametersString;
         return this;
     }
     addG(g) {
@@ -131,13 +202,19 @@ export class Builder {
     addTimeoutMillis(timeout) {
         if (timeout < 0)
             throw new Error('timeout argument cannot be negative.');
-        this.timeoutMs = timeout;
+        this.timeoutMillis = timeout;
         return this;
     }
     addBulkResults(bulking) {
         this.bulkResults = bulking;
         return this;
     }
+    addBatchSize(batchSize) {
+        if (batchSize <= 0)
+            throw new Error('batchSize argument must be positive.');
+        this.batchSize = batchSize;
+        return this;
+    }
     addField(key, value) {
         this.additionalFields.set(key, value);
         return this;
@@ -146,7 +223,16 @@ export class Builder {
      * Create the request message given the settings provided to the Builder.
      */
     create() {
+        // mutual exclusion between addParameters/addParameter and addParametersString is
+        // enforced at call time, so only one path can be set here
+        let parameters;
+        if (this.parametersString) {
+            parameters = this.parametersString;
+        }
+        else if (Object.keys(this.parameters).length > 0) {
+            parameters = GremlinLang.convertParametersToString(new Map(Object.entries(this.parameters)));
+        }
         // @ts-ignore - accessing private constructor from Builder
-        return new RequestMessage(this.gremlin, this.language || 'gremlin-lang', this.timeoutMs, Object.keys(this.bindings).length > 0 ? this.bindings : undefined, this.g, this.materializeProperties, this.bulkResults, this.additionalFields);
+        return new RequestMessage(this.gremlin, this.language || 'gremlin-lang', this.timeoutMillis, parameters, this.g, this.materializeProperties, this.bulkResults, this.batchSize, this.additionalFields);
     }
 }

package/build/esm/driver/response-error.d.ts

@@ -4,10 +4,10 @@
 export default class ResponseError extends Error {
     statusCode: number;
     statusMessage: string;
-    statusAttributes: Map<string, string>;
+    statusException: string | null;
     constructor(message: string, responseStatus: {
         code: ResponseError['statusCode'];
         message: ResponseError['statusMessage'];
-        attributes: ResponseError['statusAttributes'];
+        exception?: ResponseError['statusException'];
     });
 }

package/build/esm/driver/response-error.js

@@ -22,7 +22,7 @@
 export default class ResponseError extends Error {
     statusCode;
     statusMessage;
-    statusAttributes;
+    statusException;
     constructor(message, responseStatus) {
         super(message);
         this.name = 'ResponseError';
@@ -35,8 +35,8 @@ export default class ResponseError extends Error {
          */
         this.statusMessage = responseStatus.message;
         /**
-         * Gets the server status attributes as a Map (may contain provider specific status information).
+         * Gets the server exception string (v4 protocol).
          */
-        this.statusAttributes = responseStatus.attributes || {};
+        this.statusException = responseStatus.exception ?? null;
     }
 }