@goplus123/core-api 1.1.3 → 1.1.4

package/dist/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;// src/client/grpcClient.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10; var _class11; var _class12; var _class13;// src/client/grpcClient.ts
 var _connect = require('@connectrpc/connect');
 var _connectweb = require('@connectrpc/connect-web');
 var _protobuf = require('@bufbuild/protobuf');
@@ -1550,10 +1550,12 @@ var WsApiError = (_class6 = class extends Error {
     this.cause = options.cause;
   }
 }, _class6);
-var WsRpcClient = class {
+var WsRpcClient = (_class7 = class {
   
   
-  constructor(ws, options = {}) {
+  __init19() {this.adapters = exports.adapters = []}
+  
+  constructor(ws, options = {}) {;_class7.prototype.__init19.call(this);
     this.ws = ws;
     this.options = {
       defaultTimeout: _nullishCoalesce(options.defaultTimeout, () => ( 1e4)),
@@ -1566,6 +1568,78 @@ var WsRpcClient = class {
       onError: options.onError
     };
   }
+  addAdapter(adapter, options) {
+    const prepend = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _166 => _166.prepend]), () => ( true));
+    if (prepend) {
+      this.adapters.unshift(adapter);
+    } else {
+      this.adapters.push(adapter);
+    }
+    return () => {
+      this.adapters = this.adapters.filter((a) => a !== adapter);
+    };
+  }
+  clearAdapters() {
+    this.adapters = [];
+  }
+  setDefaultAdapter(adapter) {
+    this.defaultAdapter = adapter;
+  }
+  matchAdapter(match, service, functionName) {
+    if (typeof match === "function") return match({ service, functionName });
+    if (match.service !== void 0) {
+      if (typeof match.service === "string") {
+        if (match.service !== service) return false;
+      } else if (!match.service.test(service)) {
+        return false;
+      }
+    }
+    if (match.functionName !== void 0) {
+      if (typeof match.functionName === "string") {
+        if (match.functionName !== functionName) return false;
+      } else if (!match.functionName.test(functionName)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  resolveAdapter(service, functionName) {
+    for (const adapter of this.adapters) {
+      if (this.matchAdapter(adapter.match, service, functionName)) return adapter;
+    }
+    if (this.defaultAdapter && this.matchAdapter(this.defaultAdapter.match, service, functionName)) {
+      return this.defaultAdapter;
+    }
+    return void 0;
+  }
+  isOkWithAdapter(value, adapter) {
+    if (_optionalChain([adapter, 'optionalAccess', _167 => _167.isSuccess])) return adapter.isSuccess(value);
+    return this.isOk(value);
+  }
+  extractRequestIdWithAdapter(value, adapter) {
+    const mapped = _optionalChain([adapter, 'optionalAccess', _168 => _168.getRequestId, 'optionalCall', _169 => _169(value)]);
+    const normalized = this.normalizeString(mapped);
+    if (normalized) return normalized;
+    return this.extractRequestId(value);
+  }
+  extractCodeWithAdapter(value, adapter) {
+    const mapped = _nullishCoalesce(_optionalChain([adapter, 'optionalAccess', _170 => _170.getBizCode, 'optionalCall', _171 => _171(value)]), () => ( _optionalChain([adapter, 'optionalAccess', _172 => _172.getCode, 'optionalCall', _173 => _173(value)])));
+    const normalized = this.normalizeNumber(mapped);
+    if (normalized !== void 0) return normalized;
+    return this.extractCode(value);
+  }
+  extractStatusWithAdapter(value, adapter) {
+    const mapped = _optionalChain([adapter, 'optionalAccess', _174 => _174.getStatus, 'optionalCall', _175 => _175(value)]);
+    const normalized = this.normalizeNumber(mapped);
+    if (normalized !== void 0) return normalized;
+    return this.extractStatus(value);
+  }
+  getErrorMessageWithAdapter(value, adapter) {
+    const mapped = _optionalChain([adapter, 'optionalAccess', _176 => _176.getMessage, 'optionalCall', _177 => _177(value)]);
+    const normalized = this.normalizeString(mapped);
+    if (normalized) return normalized;
+    return this.getErrorMessage(value);
+  }
   normalizeNumber(value) {
     if (typeof value === "number" && Number.isFinite(value)) return value;
     if (typeof value === "string") {
@@ -1606,7 +1680,7 @@ var WsRpcClient = class {
     }
     if (!value || typeof value !== "object") return void 0;
     const anyValue = value;
-    const id = _nullishCoalesce(anyValue.requestId, () => ( _optionalChain([anyValue, 'optionalAccess', _166 => _166.data, 'optionalAccess', _167 => _167.requestId])));
+    const id = _nullishCoalesce(anyValue.requestId, () => ( _optionalChain([anyValue, 'optionalAccess', _178 => _178.data, 'optionalAccess', _179 => _179.requestId])));
     return this.normalizeString(id);
   }
   extractCode(value) {
@@ -1655,10 +1729,10 @@ var WsRpcClient = class {
     let res;
     try {
       res = await this.ws.request(functionName, service, finalPayload, {
-        timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _168 => _168.timeout]), () => ( this.options.defaultTimeout)),
-        responseFunctionName: _optionalChain([options, 'optionalAccess', _169 => _169.responseFunctionName]),
-        matchRequestId: _optionalChain([options, 'optionalAccess', _170 => _170.matchRequestId]),
-        filter: _optionalChain([options, 'optionalAccess', _171 => _171.filter])
+        timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _180 => _180.timeout]), () => ( this.options.defaultTimeout)),
+        responseFunctionName: _optionalChain([options, 'optionalAccess', _181 => _181.responseFunctionName]),
+        matchRequestId: _optionalChain([options, 'optionalAccess', _182 => _182.matchRequestId]),
+        filter: _optionalChain([options, 'optionalAccess', _183 => _183.filter])
       });
     } catch (err) {
       const wrapped = new WsApiError({
@@ -1666,32 +1740,36 @@ var WsRpcClient = class {
         service,
         functionName,
         requestId,
-        message: _optionalChain([err, 'optionalAccess', _172 => _172.message]),
+        message: _optionalChain([err, 'optionalAccess', _184 => _184.message]),
         cause: err
       });
       try {
-        _optionalChain([this, 'access', _173 => _173.options, 'access', _174 => _174.onError, 'optionalCall', _175 => _175(wrapped, { service, functionName, requestId })]);
+        _optionalChain([this, 'access', _185 => _185.options, 'access', _186 => _186.onError, 'optionalCall', _187 => _187(wrapped, { service, functionName, requestId })]);
       } catch (e12) {
       }
       throw wrapped;
     }
-    if (!this.isOk(res)) {
-      const responseRequestId = _nullishCoalesce(this.extractRequestId(res), () => ( requestId));
+    const adapter = this.resolveAdapter(service, functionName);
+    if (!this.isOkWithAdapter(res, adapter)) {
+      const responseRequestId = _nullishCoalesce(this.extractRequestIdWithAdapter(res, adapter), () => ( requestId));
       const wrapped = new WsApiError({
         kind: "biz_error",
         service,
         functionName,
         requestId: responseRequestId,
-        code: this.extractCode(res),
-        status: this.extractStatus(res),
-        message: _nullishCoalesce(this.getErrorMessage(res), () => ( "Request failed"))
+        code: this.extractCodeWithAdapter(res, adapter),
+        status: this.extractStatusWithAdapter(res, adapter),
+        message: _nullishCoalesce(this.getErrorMessageWithAdapter(res, adapter), () => ( "Request failed"))
       });
       try {
-        _optionalChain([this, 'access', _176 => _176.options, 'access', _177 => _177.onError, 'optionalCall', _178 => _178(wrapped, { service, functionName, requestId: responseRequestId })]);
+        _optionalChain([this, 'access', _188 => _188.options, 'access', _189 => _189.onError, 'optionalCall', _190 => _190(wrapped, { service, functionName, requestId: responseRequestId })]);
       } catch (e13) {
       }
       throw wrapped;
     }
+    if (_optionalChain([adapter, 'optionalAccess', _191 => _191.unwrap])) {
+      return adapter.unwrap(res);
+    }
     if (this.options.unwrapData && res && typeof res === "object" && "data" in res) {
       return res.data;
     }
@@ -1703,10 +1781,10 @@ var WsRpcClient = class {
     let res;
     try {
       res = await this.ws.request(functionName, service, finalPayload, {
-        timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _179 => _179.timeout]), () => ( this.options.defaultTimeout)),
-        responseFunctionName: _optionalChain([options, 'optionalAccess', _180 => _180.responseFunctionName]),
-        matchRequestId: _optionalChain([options, 'optionalAccess', _181 => _181.matchRequestId]),
-        filter: _optionalChain([options, 'optionalAccess', _182 => _182.filter])
+        timeout: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _192 => _192.timeout]), () => ( this.options.defaultTimeout)),
+        responseFunctionName: _optionalChain([options, 'optionalAccess', _193 => _193.responseFunctionName]),
+        matchRequestId: _optionalChain([options, 'optionalAccess', _194 => _194.matchRequestId]),
+        filter: _optionalChain([options, 'optionalAccess', _195 => _195.filter])
       });
     } catch (err) {
       const wrapped = new WsApiError({
@@ -1714,28 +1792,29 @@ var WsRpcClient = class {
         service,
         functionName,
         requestId,
-        message: _optionalChain([err, 'optionalAccess', _183 => _183.message]),
+        message: _optionalChain([err, 'optionalAccess', _196 => _196.message]),
         cause: err
       });
       try {
-        _optionalChain([this, 'access', _184 => _184.options, 'access', _185 => _185.onError, 'optionalCall', _186 => _186(wrapped, { service, functionName, requestId })]);
+        _optionalChain([this, 'access', _197 => _197.options, 'access', _198 => _198.onError, 'optionalCall', _199 => _199(wrapped, { service, functionName, requestId })]);
       } catch (e14) {
       }
       throw wrapped;
     }
-    if (!this.isOk(res)) {
-      const responseRequestId = _nullishCoalesce(this.extractRequestId(res), () => ( requestId));
+    const adapter = this.resolveAdapter(service, functionName);
+    if (!this.isOkWithAdapter(res, adapter)) {
+      const responseRequestId = _nullishCoalesce(this.extractRequestIdWithAdapter(res, adapter), () => ( requestId));
       const wrapped = new WsApiError({
         kind: "biz_error",
         service,
         functionName,
         requestId: responseRequestId,
-        code: this.extractCode(res),
-        status: this.extractStatus(res),
-        message: _nullishCoalesce(this.getErrorMessage(res), () => ( "Request failed"))
+        code: this.extractCodeWithAdapter(res, adapter),
+        status: this.extractStatusWithAdapter(res, adapter),
+        message: _nullishCoalesce(this.getErrorMessageWithAdapter(res, adapter), () => ( "Request failed"))
       });
       try {
-        _optionalChain([this, 'access', _187 => _187.options, 'access', _188 => _188.onError, 'optionalCall', _189 => _189(wrapped, { service, functionName, requestId: responseRequestId })]);
+        _optionalChain([this, 'access', _200 => _200.options, 'access', _201 => _201.onError, 'optionalCall', _202 => _202(wrapped, { service, functionName, requestId: responseRequestId })]);
       } catch (e15) {
       }
       throw wrapped;
@@ -1780,7 +1859,7 @@ var WsRpcClient = class {
     ]);
     return this.normalizeString(msg);
   }
-};
+}, _class7);
 
 // src/client/unifiedApiClient.ts
 
@@ -1790,6 +1869,7 @@ function isBizError(err) {
   if (!err || typeof err !== "object") return false;
   const anyErr = err;
   if (anyErr.kind === "biz") return true;
+  if (anyErr.name === "GrpcBizError") return true;
   if (anyErr.name === "WsApiError") {
     const hasCause = "cause" in anyErr && anyErr.cause != null;
     const hasCodeOrStatus = typeof anyErr.code === "number" || typeof anyErr.status === "number";
@@ -1822,17 +1902,17 @@ function createAuthInterceptor(options) {
 function createLogInterceptor(options) {
   const level = _nullishCoalesce(options.level, () => ( "debug"));
   const logger = options.logger;
-  const log = level === "info" ? _optionalChain([logger, 'optionalAccess', _190 => _190.info]) : _optionalChain([logger, 'optionalAccess', _191 => _191.debug]);
+  const log = level === "info" ? _optionalChain([logger, 'optionalAccess', _203 => _203.info]) : _optionalChain([logger, 'optionalAccess', _204 => _204.debug]);
   return (next) => async (ctx) => {
     const startedAt = Date.now();
-    _optionalChain([log, 'optionalCall', _192 => _192("api.request", {
+    _optionalChain([log, 'optionalCall', _205 => _205("api.request", {
       endpointId: ctx.endpoint.id,
       transport: ctx.endpoint.transport,
       meta: ctx.meta
     })]);
     try {
       const res = await next(ctx);
-      _optionalChain([log, 'optionalCall', _193 => _193("api.response", {
+      _optionalChain([log, 'optionalCall', _206 => _206("api.response", {
         endpointId: ctx.endpoint.id,
         transport: ctx.endpoint.transport,
         durationMs: Date.now() - startedAt,
@@ -1841,8 +1921,8 @@ function createLogInterceptor(options) {
       return res;
     } catch (err) {
       const event = isBizError(err) ? "api.biz_error" : "api.transport_error";
-      const report = isBizError(err) ? _nullishCoalesce(_optionalChain([logger, 'optionalAccess', _194 => _194.warn]), () => ( _optionalChain([logger, 'optionalAccess', _195 => _195.error]))) : _nullishCoalesce(_nullishCoalesce(_optionalChain([logger, 'optionalAccess', _196 => _196.error]), () => ( _optionalChain([logger, 'optionalAccess', _197 => _197.warn]))), () => ( _optionalChain([logger, 'optionalAccess', _198 => _198.info])));
-      _optionalChain([report, 'optionalCall', _199 => _199(event, {
+      const report = isBizError(err) ? _nullishCoalesce(_optionalChain([logger, 'optionalAccess', _207 => _207.warn]), () => ( _optionalChain([logger, 'optionalAccess', _208 => _208.error]))) : _nullishCoalesce(_nullishCoalesce(_optionalChain([logger, 'optionalAccess', _209 => _209.error]), () => ( _optionalChain([logger, 'optionalAccess', _210 => _210.warn]))), () => ( _optionalChain([logger, 'optionalAccess', _211 => _211.info])));
+      _optionalChain([report, 'optionalCall', _212 => _212(event, {
         endpointId: ctx.endpoint.id,
         transport: ctx.endpoint.transport,
         durationMs: Date.now() - startedAt,
@@ -1855,6 +1935,25 @@ function createLogInterceptor(options) {
 }
 
 // src/client/unifiedApiClient.ts
+var GrpcBizError = (_class8 = class extends Error {
+  __init20() {this.name = "GrpcBizError"}
+  __init21() {this.kind = "biz"}
+  
+  
+  
+  
+  
+  
+  constructor(options) {
+    super(_nullishCoalesce(options.message, () => ( "gRPC request failed")));_class8.prototype.__init20.call(this);_class8.prototype.__init21.call(this);;
+    this.endpointId = options.endpointId;
+    this.serviceTypeName = options.serviceTypeName;
+    this.methodName = options.methodName;
+    this.code = options.code;
+    this.status = options.status;
+    this.raw = options.raw;
+  }
+}, _class8);
 function normalizeApiError(err, source) {
   let endpoint;
   let transport;
@@ -1880,7 +1979,7 @@ function normalizeApiError(err, source) {
       }
       if (endpoint.transport === "grpc") {
         return {
-          service: _optionalChain([endpoint, 'access', _200 => _200.grpc, 'access', _201 => _201.service, 'optionalAccess', _202 => _202.typeName]),
+          service: _optionalChain([endpoint, 'access', _213 => _213.grpc, 'access', _214 => _214.service, 'optionalAccess', _215 => _215.typeName]),
           functionName: endpoint.grpc.methodName
         };
       }
@@ -1928,6 +2027,19 @@ function normalizeApiError(err, source) {
       raw: err
     };
   }
+  if (err instanceof GrpcBizError) {
+    return {
+      category,
+      endpointId,
+      transport: "grpc",
+      service: _nullishCoalesce(err.serviceTypeName, () => ( fallback.service)),
+      functionName: _nullishCoalesce(err.methodName, () => ( fallback.functionName)),
+      code: err.code,
+      status: err.status,
+      message: _nullishCoalesce(err.message, () => ( "gRPC request failed")),
+      raw: err.raw
+    };
+  }
   const anyErr = err;
   return {
     category,
@@ -1935,13 +2047,13 @@ function normalizeApiError(err, source) {
     transport,
     service: fallback.service,
     functionName: fallback.functionName,
-    code: _optionalChain([anyErr, 'optionalAccess', _203 => _203.code]),
-    status: typeof _optionalChain([anyErr, 'optionalAccess', _204 => _204.status]) === "number" ? anyErr.status : void 0,
-    message: _nullishCoalesce(_optionalChain([anyErr, 'optionalAccess', _205 => _205.message]), () => ( (typeof err === "string" ? err : "Request failed"))),
+    code: _optionalChain([anyErr, 'optionalAccess', _216 => _216.code]),
+    status: typeof _optionalChain([anyErr, 'optionalAccess', _217 => _217.status]) === "number" ? anyErr.status : void 0,
+    message: _nullishCoalesce(_optionalChain([anyErr, 'optionalAccess', _218 => _218.message]), () => ( (typeof err === "string" ? err : "Request failed"))),
     raw: err
   };
 }
-var UnifiedApiClient = class {
+var UnifiedApiClient = (_class9 = class {
   /**
    * 统一调用入口：
    * - 输入：EndpointSpec（来自 spec 层）+ request + meta
@@ -1955,12 +2067,31 @@ var UnifiedApiClient = class {
   
   
   
-  constructor(deps, options) {
+  __init22() {this.grpcAdapters = []}
+  
+  constructor(deps, options) {;_class9.prototype.__init22.call(this);
     this.http = deps.http;
     this.rpc = deps.rpc;
     this.grpc = deps.grpc;
-    this.callChain = composeInterceptors(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _206 => _206.interceptors]), () => ( [])), (ctx) => this.dispatch(ctx));
-    this.onError = _optionalChain([options, 'optionalAccess', _207 => _207.onError]);
+    this.callChain = composeInterceptors(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _219 => _219.interceptors]), () => ( [])), (ctx) => this.dispatch(ctx));
+    this.onError = _optionalChain([options, 'optionalAccess', _220 => _220.onError]);
+  }
+  addGrpcAdapter(adapter, options) {
+    const prepend = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _221 => _221.prepend]), () => ( true));
+    if (prepend) {
+      this.grpcAdapters.unshift(adapter);
+    } else {
+      this.grpcAdapters.push(adapter);
+    }
+    return () => {
+      this.grpcAdapters = this.grpcAdapters.filter((a) => a !== adapter);
+    };
+  }
+  clearGrpcAdapters() {
+    this.grpcAdapters = [];
+  }
+  setGrpcDefaultAdapter(adapter) {
+    this.grpcDefaultAdapter = adapter;
   }
   setErrorHandler(handler) {
     this.onError = handler;
@@ -1999,16 +2130,16 @@ var UnifiedApiClient = class {
       });
     }
     if (endpoint.transport === "ws") {
-      const wsOptions = _optionalChain([ctx, 'access', _208 => _208.meta, 'optionalAccess', _209 => _209.wsOptions]);
+      const wsOptions = _optionalChain([ctx, 'access', _222 => _222.meta, 'optionalAccess', _223 => _223.wsOptions]);
       return await this.rpc.request(
         endpoint.ws.functionName,
         endpoint.ws.service,
         ctx.request,
         {
-          timeout: _nullishCoalesce(_optionalChain([wsOptions, 'optionalAccess', _210 => _210.timeout]), () => ( endpoint.ws.timeout)),
-          responseFunctionName: _nullishCoalesce(_optionalChain([wsOptions, 'optionalAccess', _211 => _211.responseFunctionName]), () => ( endpoint.ws.responseFunctionName)),
-          matchRequestId: _optionalChain([wsOptions, 'optionalAccess', _212 => _212.matchRequestId]),
-          filter: _optionalChain([wsOptions, 'optionalAccess', _213 => _213.filter])
+          timeout: _nullishCoalesce(_optionalChain([wsOptions, 'optionalAccess', _224 => _224.timeout]), () => ( endpoint.ws.timeout)),
+          responseFunctionName: _nullishCoalesce(_optionalChain([wsOptions, 'optionalAccess', _225 => _225.responseFunctionName]), () => ( endpoint.ws.responseFunctionName)),
+          matchRequestId: _optionalChain([wsOptions, 'optionalAccess', _226 => _226.matchRequestId]),
+          filter: _optionalChain([wsOptions, 'optionalAccess', _227 => _227.filter])
         }
       );
     }
@@ -2019,12 +2150,142 @@ var UnifiedApiClient = class {
     if (typeof method !== "function") {
       throw new Error(`gRPC method not found: ${service.typeName}.${methodName}`);
     }
-    const callOptions = _optionalChain([ctx, 'access', _214 => _214.meta, 'optionalAccess', _215 => _215.callOptions]);
+    const callOptions = _optionalChain([ctx, 'access', _228 => _228.meta, 'optionalAccess', _229 => _229.callOptions]);
     const req = endpoint.grpc.requestSchema ? _protobuf.create.call(void 0, endpoint.grpc.requestSchema, _nullishCoalesce(ctx.request, () => ( {}))) : ctx.request;
-    const headers = { ..._nullishCoalesce(_optionalChain([callOptions, 'optionalAccess', _216 => _216.headers]), () => ( {})), ..._nullishCoalesce(ctx.headers, () => ( {})) };
-    return await method(req, { ..._nullishCoalesce(callOptions, () => ( {})), headers });
+    const headers = { ..._nullishCoalesce(_optionalChain([callOptions, 'optionalAccess', _230 => _230.headers]), () => ( {})), ..._nullishCoalesce(ctx.headers, () => ( {})) };
+    const res = await method(req, { ..._nullishCoalesce(callOptions, () => ( {})), headers });
+    const adapter = this.resolveGrpcAdapter({
+      endpointId: endpoint.id,
+      serviceTypeName: service.typeName,
+      methodName
+    });
+    if (!adapter) return res;
+    if (!this.isGrpcOkWithAdapter(res, adapter)) {
+      throw new GrpcBizError({
+        endpointId: endpoint.id,
+        serviceTypeName: service.typeName,
+        methodName,
+        code: this.extractGrpcCodeWithAdapter(res, adapter),
+        status: this.extractGrpcStatusWithAdapter(res, adapter),
+        message: _nullishCoalesce(this.getGrpcErrorMessageWithAdapter(res, adapter), () => ( "Request failed")),
+        raw: res
+      });
+    }
+    if (adapter.unwrap) return adapter.unwrap(res);
+    return res;
   }
-};
+  matchGrpcAdapter(match, ctx) {
+    if (typeof match === "function") return match(ctx);
+    if (match.endpointId !== void 0) {
+      if (typeof match.endpointId === "string") {
+        if (match.endpointId !== ctx.endpointId) return false;
+      } else if (!match.endpointId.test(ctx.endpointId)) {
+        return false;
+      }
+    }
+    if (match.serviceTypeName !== void 0) {
+      if (typeof match.serviceTypeName === "string") {
+        if (match.serviceTypeName !== ctx.serviceTypeName) return false;
+      } else if (!match.serviceTypeName.test(ctx.serviceTypeName)) {
+        return false;
+      }
+    }
+    if (match.methodName !== void 0) {
+      if (typeof match.methodName === "string") {
+        if (match.methodName !== ctx.methodName) return false;
+      } else if (!match.methodName.test(ctx.methodName)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  resolveGrpcAdapter(ctx) {
+    for (const adapter of this.grpcAdapters) {
+      if (this.matchGrpcAdapter(adapter.match, ctx)) return adapter;
+    }
+    if (this.grpcDefaultAdapter && this.matchGrpcAdapter(this.grpcDefaultAdapter.match, ctx)) {
+      return this.grpcDefaultAdapter;
+    }
+    return void 0;
+  }
+  normalizeNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (!trimmed) return void 0;
+      const asNumber = Number(trimmed);
+      return Number.isFinite(asNumber) ? asNumber : void 0;
+    }
+    return void 0;
+  }
+  normalizeString(value) {
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      return trimmed.length > 0 ? trimmed : void 0;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) return String(value);
+    return void 0;
+  }
+  pickField(value, keys) {
+    if (!value || typeof value !== "object") return void 0;
+    const anyValue = value;
+    for (const key of keys) {
+      if (anyValue[key] !== void 0) return anyValue[key];
+    }
+    return void 0;
+  }
+  isGrpcOk(value) {
+    if (!value || typeof value !== "object") return true;
+    const rawSuccess = this.pickField(value, ["success", "ok"]);
+    if (rawSuccess !== void 0) {
+      if (typeof rawSuccess === "boolean") return rawSuccess;
+      if (typeof rawSuccess === "string") {
+        const lowered = rawSuccess.trim().toLowerCase();
+        if (lowered === "true") return true;
+        if (lowered === "false") return false;
+      }
+    }
+    const rawCode = this.pickField(value, ["code", "errCode", "errorCode", "resultCode"]);
+    if (rawCode !== void 0) {
+      const code = this.normalizeNumber(rawCode);
+      return typeof code === "number" ? code === 0 || code === 200 : false;
+    }
+    const rawStatus = this.pickField(value, ["status", "statusCode", "httpStatus", "http_code"]);
+    if (rawStatus !== void 0) {
+      const status = this.normalizeNumber(rawStatus);
+      return typeof status === "number" ? status === 0 || status === 200 : false;
+    }
+    return true;
+  }
+  isGrpcOkWithAdapter(value, adapter) {
+    if (adapter.isSuccess) return adapter.isSuccess(value);
+    return this.isGrpcOk(value);
+  }
+  extractGrpcCodeWithAdapter(value, adapter) {
+    const mapped = _nullishCoalesce(_optionalChain([adapter, 'access', _231 => _231.getBizCode, 'optionalCall', _232 => _232(value)]), () => ( _optionalChain([adapter, 'access', _233 => _233.getCode, 'optionalCall', _234 => _234(value)])));
+    const normalized = this.normalizeNumber(mapped);
+    if (normalized !== void 0) return normalized;
+    return this.normalizeNumber(
+      this.pickField(value, ["code", "errCode", "errorCode", "resultCode"])
+    );
+  }
+  extractGrpcStatusWithAdapter(value, adapter) {
+    const mapped = _optionalChain([adapter, 'access', _235 => _235.getStatus, 'optionalCall', _236 => _236(value)]);
+    const normalized = this.normalizeNumber(mapped);
+    if (normalized !== void 0) return normalized;
+    return this.normalizeNumber(
+      this.pickField(value, ["status", "statusCode", "httpStatus", "http_code"])
+    );
+  }
+  getGrpcErrorMessageWithAdapter(value, adapter) {
+    const mapped = _optionalChain([adapter, 'access', _237 => _237.getMessage, 'optionalCall', _238 => _238(value)]);
+    const normalized = this.normalizeString(mapped);
+    if (normalized) return normalized;
+    return this.normalizeString(
+      this.pickField(value, ["message", "msg", "error", "errMsg", "errmsg", "errorMessage"])
+    );
+  }
+}, _class9);
 
 // src/utils/adapters/web.ts
 var webStorage = {
@@ -2058,7 +2319,7 @@ function createFetchGuid(storage, options) {
   return () => fetchGuidWithStorage(storage, options);
 }
 function fetchGuidWithStorage(storage, options) {
-  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _217 => _217.key]), () => ( defaultKey));
+  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _239 => _239.key]), () => ( defaultKey));
   const current = safeGet(storage, key);
   if (current) {
     const unmasked = unmaskGuid(current);
@@ -2117,8 +2378,8 @@ function unmaskGuid(value) {
   return hex.replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
 }
 function formatGuid(guid, options) {
-  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _218 => _218.format]), () => ( "uuid"));
-  const prefix = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _219 => _219.prefix]), () => ( ""));
+  const format = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _240 => _240.format]), () => ( "uuid"));
+  const prefix = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _241 => _241.prefix]), () => ( ""));
   if (format === "uuid") return prefix + guid;
   const hex = guid.replace(/-/g, "");
   if (format === "hex") return prefix + hex;
@@ -2454,7 +2715,7 @@ function requestApi(args) {
       return waitForSdkInit().then(() => requestApi(args));
     }
     const serviceInstance2 = serviceInstances[args.service];
-    const method2 = _optionalChain([serviceInstance2, 'optionalAccess', _220 => _220[args.functionName]]);
+    const method2 = _optionalChain([serviceInstance2, 'optionalAccess', _242 => _242[args.functionName]]);
     if (typeof method2 === "function") {
       if (args.callOptions !== void 0) {
         return method2(args.requestParam, args.callOptions);
@@ -2467,7 +2728,7 @@ function requestApi(args) {
     throw new Error(`Endpoint not found: ${args.service}.${args.functionName} (http)`);
   }
   const serviceInstance = serviceInstances[args.service];
-  const method = _optionalChain([serviceInstance, 'optionalAccess', _221 => _221[args.functionName]]);
+  const method = _optionalChain([serviceInstance, 'optionalAccess', _243 => _243[args.functionName]]);
   if (typeof method === "function") {
     if (args.callOptions !== void 0) {
       return method(args.requestParam, args.callOptions);
@@ -2531,7 +2792,7 @@ function createLazyObject(loader) {
         if (prop === "then") return void 0;
         if (prop === "__load") return load;
         return (...args) => load().then((obj) => {
-          const value = _optionalChain([obj, 'optionalAccess', _222 => _222[prop]]);
+          const value = _optionalChain([obj, 'optionalAccess', _244 => _244[prop]]);
           if (typeof value === "function") return value.apply(obj, args);
           return value;
         });
@@ -2579,8 +2840,8 @@ function detachNotifyRegistration(reg) {
 }
 function getWsSnapshot() {
   return {
-    readyState: _optionalChain([api, 'optionalAccess', _223 => _223.ws]) ? api.ws.state : void 0,
-    isConnected: _optionalChain([api, 'optionalAccess', _224 => _224.ws]) ? api.ws.isConnected : false,
+    readyState: _optionalChain([api, 'optionalAccess', _245 => _245.ws]) ? api.ws.state : void 0,
+    isConnected: _optionalChain([api, 'optionalAccess', _246 => _246.ws]) ? api.ws.isConnected : false,
     status: wsStatusSnapshot
   };
 }
@@ -2593,8 +2854,8 @@ function clearWsStatusBridge() {
   }
   wsStatusOffs = [];
 }
-var Pipeline = (_class7 = class {constructor() { _class7.prototype.__init19.call(this); }
-  __init19() {this.handlers = []}
+var Pipeline = (_class10 = class {constructor() { _class10.prototype.__init23.call(this); }
+  __init23() {this.handlers = []}
   use(handler) {
     this.handlers.push(handler);
     return () => {
@@ -2613,9 +2874,9 @@ var Pipeline = (_class7 = class {constructor() { _class7.prototype.__init19.call
     };
     return await next();
   }
-}, _class7);
-var ApiErrorCenter = (_class8 = class {constructor() { _class8.prototype.__init20.call(this); }
-  __init20() {this.pipeline = new Pipeline()}
+}, _class10);
+var ApiErrorCenter = (_class11 = class {constructor() { _class11.prototype.__init24.call(this); }
+  __init24() {this.pipeline = new Pipeline()}
   use(handler) {
     return this.pipeline.use(async (error, ctx, next) => {
       try {
@@ -2634,7 +2895,7 @@ var ApiErrorCenter = (_class8 = class {constructor() { _class8.prototype.__init2
   clear() {
     this.pipeline.clear();
   }
-}, _class8);
+}, _class11);
 var apiError = {
   use(handler) {
     const id = ++apiErrorRegistrationSeq;
@@ -2656,12 +2917,12 @@ var apiError = {
     return apiErrorCenter.emit(error, source);
   }
 };
-var NotifyChannel = (_class9 = class {
-  constructor(type, wsNotify) {;_class9.prototype.__init21.call(this);
+var NotifyChannel = (_class12 = class {
+  constructor(type, wsNotify) {;_class12.prototype.__init25.call(this);
     this.type = type;
     this.wsNotify = wsNotify;
   }
-  __init21() {this.pipeline = new Pipeline()}
+  __init25() {this.pipeline = new Pipeline()}
   
   ensureAttached() {
     if (!this.wsNotify) return;
@@ -2699,12 +2960,12 @@ var NotifyChannel = (_class9 = class {
     }
     this.pipeline.clear();
   }
-}, _class9);
-var NotifyCenter = (_class10 = class {
-  constructor(wsNotify) {;_class10.prototype.__init22.call(this);
+}, _class12);
+var NotifyCenter = (_class13 = class {
+  constructor(wsNotify) {;_class13.prototype.__init26.call(this);
     this.wsNotify = wsNotify;
   }
-  __init22() {this.channels = /* @__PURE__ */ new Map()}
+  __init26() {this.channels = /* @__PURE__ */ new Map()}
   channel(type) {
     const existing = this.channels.get(type);
     if (existing) return existing;
@@ -2718,7 +2979,7 @@ var NotifyCenter = (_class10 = class {
     }
     this.channels.clear();
   }
-}, _class10);
+}, _class13);
 function notify(type) {
   const channel = {
     use(handler) {
@@ -2728,7 +2989,7 @@ function notify(type) {
       attachNotifyRegistration(type, reg);
       return () => {
         const map = notifyRegistrationsByType.get(type);
-        const current = _optionalChain([map, 'optionalAccess', _225 => _225.get, 'call', _226 => _226(id)]);
+        const current = _optionalChain([map, 'optionalAccess', _247 => _247.get, 'call', _248 => _248(id)]);
         if (!map || !current) return;
         detachNotifyRegistration(current);
         map.delete(id);
@@ -2742,7 +3003,7 @@ function notify(type) {
       attachNotifyRegistration(type, reg);
       return () => {
         const map = notifyRegistrationsByType.get(type);
-        const current = _optionalChain([map, 'optionalAccess', _227 => _227.get, 'call', _228 => _228(id)]);
+        const current = _optionalChain([map, 'optionalAccess', _249 => _249.get, 'call', _250 => _250(id)]);
         if (!map || !current) return;
         detachNotifyRegistration(current);
         map.delete(id);
@@ -2764,13 +3025,121 @@ function notify(type) {
         }
         notifyRegistrationsByType.delete(type);
       }
-      _optionalChain([notifyCenter, 'optionalAccess', _229 => _229.channel, 'call', _230 => _230(type), 'access', _231 => _231.destroy, 'call', _232 => _232()]);
+      _optionalChain([notifyCenter, 'optionalAccess', _251 => _251.channel, 'call', _252 => _252(type), 'access', _253 => _253.destroy, 'call', _254 => _254()]);
     }
   };
   return channel;
 }
+var wsAdapterRegistrationSeq = 0;
+var wsAdapterRegistrations = /* @__PURE__ */ new Map();
+var wsDefaultAdapter;
+var wsAdapterRpc;
+function attachWsAdapterRegistration(reg) {
+  if (!wsAdapterRpc) return;
+  if (reg.off) reg.off();
+  reg.off = wsAdapterRpc.addAdapter(reg.adapter, { prepend: reg.prepend });
+}
+function detachWsAdapterRegistration(reg) {
+  if (reg.off) reg.off();
+  reg.off = void 0;
+}
+function setWsAdapterRpc(next) {
+  if (wsAdapterRpc === next) return;
+  for (const reg of wsAdapterRegistrations.values()) {
+    detachWsAdapterRegistration(reg);
+  }
+  wsAdapterRpc = next;
+  if (!wsAdapterRpc) return;
+  wsAdapterRpc.clearAdapters();
+  wsAdapterRpc.setDefaultAdapter(wsDefaultAdapter);
+  for (const reg of wsAdapterRegistrations.values()) {
+    attachWsAdapterRegistration(reg);
+  }
+}
+var adapters = {
+  ws: {
+    add(adapter, options) {
+      const id = ++wsAdapterRegistrationSeq;
+      const reg = { adapter, prepend: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _255 => _255.prepend]), () => ( true)) };
+      wsAdapterRegistrations.set(id, reg);
+      attachWsAdapterRegistration(reg);
+      return () => {
+        const current = wsAdapterRegistrations.get(id);
+        if (!current) return;
+        detachWsAdapterRegistration(current);
+        wsAdapterRegistrations.delete(id);
+      };
+    },
+    setDefault(adapter) {
+      wsDefaultAdapter = adapter;
+      _optionalChain([wsAdapterRpc, 'optionalAccess', _256 => _256.setDefaultAdapter, 'call', _257 => _257(adapter)]);
+    },
+    clear() {
+      for (const reg of wsAdapterRegistrations.values()) {
+        detachWsAdapterRegistration(reg);
+      }
+      wsAdapterRegistrations.clear();
+      wsDefaultAdapter = void 0;
+      _optionalChain([wsAdapterRpc, 'optionalAccess', _258 => _258.clearAdapters, 'call', _259 => _259()]);
+      _optionalChain([wsAdapterRpc, 'optionalAccess', _260 => _260.setDefaultAdapter, 'call', _261 => _261(void 0)]);
+    }
+  },
+  grpc: {
+    add(adapter, options) {
+      const id = ++grpcAdapterRegistrationSeq;
+      const reg = { adapter, prepend: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _262 => _262.prepend]), () => ( true)) };
+      grpcAdapterRegistrations.set(id, reg);
+      attachGrpcAdapterRegistration(reg);
+      return () => {
+        const current = grpcAdapterRegistrations.get(id);
+        if (!current) return;
+        detachGrpcAdapterRegistration(current);
+        grpcAdapterRegistrations.delete(id);
+      };
+    },
+    setDefault(adapter) {
+      grpcDefaultAdapter = adapter;
+      _optionalChain([grpcAdapterClient, 'optionalAccess', _263 => _263.setGrpcDefaultAdapter, 'call', _264 => _264(adapter)]);
+    },
+    clear() {
+      for (const reg of grpcAdapterRegistrations.values()) {
+        detachGrpcAdapterRegistration(reg);
+      }
+      grpcAdapterRegistrations.clear();
+      grpcDefaultAdapter = void 0;
+      _optionalChain([grpcAdapterClient, 'optionalAccess', _265 => _265.clearGrpcAdapters, 'call', _266 => _266()]);
+      _optionalChain([grpcAdapterClient, 'optionalAccess', _267 => _267.setGrpcDefaultAdapter, 'call', _268 => _268(void 0)]);
+    }
+  }
+};
+var grpcAdapterRegistrationSeq = 0;
+var grpcAdapterRegistrations = /* @__PURE__ */ new Map();
+var grpcDefaultAdapter;
+var grpcAdapterClient;
+function attachGrpcAdapterRegistration(reg) {
+  if (!grpcAdapterClient) return;
+  if (reg.off) reg.off();
+  reg.off = grpcAdapterClient.addGrpcAdapter(reg.adapter, { prepend: reg.prepend });
+}
+function detachGrpcAdapterRegistration(reg) {
+  if (reg.off) reg.off();
+  reg.off = void 0;
+}
+function setGrpcAdapterClient(next) {
+  if (grpcAdapterClient === next) return;
+  for (const reg of grpcAdapterRegistrations.values()) {
+    detachGrpcAdapterRegistration(reg);
+  }
+  grpcAdapterClient = next;
+  if (!grpcAdapterClient) return;
+  grpcAdapterClient.clearGrpcAdapters();
+  grpcAdapterClient.setGrpcDefaultAdapter(grpcDefaultAdapter);
+  for (const reg of grpcAdapterRegistrations.values()) {
+    attachGrpcAdapterRegistration(reg);
+  }
+}
 function destroySDK() {
-  if (_optionalChain([api, 'optionalAccess', _233 => _233.ws])) {
+  if (_optionalChain([api, 'optionalAccess', _269 => _269.ws])) {
     try {
       api.ws.disconnect();
     } catch (e) {
@@ -2785,12 +3154,17 @@ function destroySDK() {
       reg.off = void 0;
     }
   }
+  for (const reg of wsAdapterRegistrations.values()) {
+    reg.off = void 0;
+  }
   api = void 0;
   resetRoutingState();
-  _optionalChain([apiErrorCenter, 'optionalAccess', _234 => _234.clear, 'call', _235 => _235()]);
+  _optionalChain([apiErrorCenter, 'optionalAccess', _270 => _270.clear, 'call', _271 => _271()]);
   apiErrorCenter = void 0;
-  _optionalChain([notifyCenter, 'optionalAccess', _236 => _236.destroy, 'call', _237 => _237()]);
+  _optionalChain([notifyCenter, 'optionalAccess', _272 => _272.destroy, 'call', _273 => _273()]);
   notifyCenter = void 0;
+  setWsAdapterRpc(void 0);
+  setGrpcAdapterClient(void 0);
   clearWsStatusBridge();
   wsStatusSnapshot = void 0;
 }
@@ -2805,19 +3179,19 @@ function initSDK(config) {
   });
   resetRoutingState();
   setRequestApiInitWaitMs(_nullishCoalesce(config.requestApiInitWaitMs, () => ( 1e4)));
-  setTransportState({ hasHttp: !!config.http, hasWs: !!config.ws, hasGrpc: !!_optionalChain([config, 'access', _238 => _238.grpc, 'optionalAccess', _239 => _239.baseUrl]) });
+  setTransportState({ hasHttp: !!config.http, hasWs: !!config.ws, hasGrpc: !!_optionalChain([config, 'access', _274 => _274.grpc, 'optionalAccess', _275 => _275.baseUrl]) });
   setDefaultTransport(_nullishCoalesce(config.defaultTransport, () => ( "auto")));
   schedulePreload(rebuildEndpointRegistry);
-  _optionalChain([config, 'access', _240 => _240.logger, 'optionalAccess', _241 => _241.info, 'optionalCall', _242 => _242("sdk.initialized", {
+  _optionalChain([config, 'access', _276 => _276.logger, 'optionalAccess', _277 => _277.info, 'optionalCall', _278 => _278("sdk.initialized", {
     hasHttp: !!config.http,
     hasWs: !!config.ws,
     hasGrpc: !!config.grpc
   })]);
-  const sdk = { apiError, notify };
+  const sdk = { apiError, notify, adapters };
   apiErrorCenter = new ApiErrorCenter();
   if (config.onApiError) {
     apiErrorCenter.use((error, _ctx, next) => {
-      _optionalChain([config, 'access', _243 => _243.onApiError, 'optionalCall', _244 => _244(error)]);
+      _optionalChain([config, 'access', _279 => _279.onApiError, 'optionalCall', _280 => _280(error)]);
       return next();
     });
   }
@@ -2838,38 +3212,38 @@ function initSDK(config) {
     };
     wsStatusOffs.push(
       api.ws.on("__open__" /* OPEN */, () => {
-        emitStatus({ state: "connected", readyState: _optionalChain([api, 'optionalAccess', _245 => _245.ws, 'optionalAccess', _246 => _246.state]) });
+        emitStatus({ state: "connected", readyState: _optionalChain([api, 'optionalAccess', _281 => _281.ws, 'optionalAccess', _282 => _282.state]) });
       })
     );
     wsStatusOffs.push(
       api.ws.on("__close__" /* CLOSE */, (e) => {
         emitStatus({
           state: "disconnected",
-          code: _optionalChain([e, 'optionalAccess', _247 => _247.code]),
-          reason: _optionalChain([e, 'optionalAccess', _248 => _248.reason]),
-          readyState: _optionalChain([api, 'optionalAccess', _249 => _249.ws, 'optionalAccess', _250 => _250.state])
+          code: _optionalChain([e, 'optionalAccess', _283 => _283.code]),
+          reason: _optionalChain([e, 'optionalAccess', _284 => _284.reason]),
+          readyState: _optionalChain([api, 'optionalAccess', _285 => _285.ws, 'optionalAccess', _286 => _286.state])
         });
       })
     );
     wsStatusOffs.push(
       api.ws.on("__error__" /* ERROR */, (e) => {
-        emitStatus({ state: "error", error: e, readyState: _optionalChain([api, 'optionalAccess', _251 => _251.ws, 'optionalAccess', _252 => _252.state]) });
+        emitStatus({ state: "error", error: e, readyState: _optionalChain([api, 'optionalAccess', _287 => _287.ws, 'optionalAccess', _288 => _288.state]) });
       })
     );
     wsStatusOffs.push(
       api.ws.on("__reconnecting__" /* RECONNECTING */, (e) => {
         emitStatus({
           state: "reconnecting",
-          attempt: _optionalChain([e, 'optionalAccess', _253 => _253.attempt]),
-          maxRetries: _optionalChain([e, 'optionalAccess', _254 => _254.maxRetries]),
-          interval: _optionalChain([e, 'optionalAccess', _255 => _255.interval]),
-          readyState: _optionalChain([api, 'optionalAccess', _256 => _256.ws, 'optionalAccess', _257 => _257.state])
+          attempt: _optionalChain([e, 'optionalAccess', _289 => _289.attempt]),
+          maxRetries: _optionalChain([e, 'optionalAccess', _290 => _290.maxRetries]),
+          interval: _optionalChain([e, 'optionalAccess', _291 => _291.interval]),
+          readyState: _optionalChain([api, 'optionalAccess', _292 => _292.ws, 'optionalAccess', _293 => _293.state])
         });
       })
     );
     wsStatusOffs.push(
       api.ws.on("__reconnect_failed__" /* RECONNECT_FAILED */, () => {
-        emitStatus({ state: "reconnect_failed", readyState: _optionalChain([api, 'optionalAccess', _258 => _258.ws, 'optionalAccess', _259 => _259.state]) });
+        emitStatus({ state: "reconnect_failed", readyState: _optionalChain([api, 'optionalAccess', _294 => _294.ws, 'optionalAccess', _295 => _295.state]) });
       })
     );
     emitStatus({
@@ -2889,6 +3263,7 @@ function initSDK(config) {
       void apiErrorCenter.emit(apiErr, "ws");
     }
   });
+  setWsAdapterRpc(rpc);
   if (config.ws) {
     sdk.rpc = rpc;
     setRpcClient(rpc);
@@ -2905,13 +3280,14 @@ function initSDK(config) {
         void apiErrorCenter.emit(error, "unified");
       },
       interceptors: [
-        ..._optionalChain([config, 'access', _260 => _260.auth, 'optionalAccess', _261 => _261.getToken]) ? [createAuthInterceptor({ getToken: config.auth.getToken })] : [],
+        ..._optionalChain([config, 'access', _296 => _296.auth, 'optionalAccess', _297 => _297.getToken]) ? [createAuthInterceptor({ getToken: config.auth.getToken })] : [],
         ...config.logger ? [createLogInterceptor({ logger: config.logger, level: "debug" })] : []
       ]
     }
   );
+  setGrpcAdapterClient(sdk.client);
   setUnifiedClient(sdk.client);
-  if (_optionalChain([config, 'access', _262 => _262.grpc, 'optionalAccess', _263 => _263.baseUrl])) {
+  if (_optionalChain([config, 'access', _298 => _298.grpc, 'optionalAccess', _299 => _299.baseUrl])) {
     const legacyPromise = Promise.resolve().then(() => _interopRequireWildcard(require("./legacy-CO3UUF6P.cjs"))).then((m) => m.createLegacyServices(api.grpc));
     const loadLegacy = () => legacyPromise;
     sdk.auth = createLazyObject(
@@ -3036,11 +3412,11 @@ function createApiServiceClient(service) {
           return requestApi({
             service,
             functionName: prop,
-            transport: _optionalChain([normalized, 'optionalAccess', _264 => _264.transport]),
+            transport: _optionalChain([normalized, 'optionalAccess', _300 => _300.transport]),
             requestParam: payload,
-            wsOptions: _optionalChain([normalized, 'optionalAccess', _265 => _265.wsOptions]),
-            callOptions: _optionalChain([normalized, 'optionalAccess', _266 => _266.callOptions]),
-            meta: _optionalChain([normalized, 'optionalAccess', _267 => _267.meta])
+            wsOptions: _optionalChain([normalized, 'optionalAccess', _301 => _301.wsOptions]),
+            callOptions: _optionalChain([normalized, 'optionalAccess', _302 => _302.callOptions]),
+            meta: _optionalChain([normalized, 'optionalAccess', _303 => _303.meta])
           });
         });
       };
@@ -3062,5 +3438,6 @@ function createApiServiceClient(service) {
 
 
 
-exports.apiError = apiError; exports.callApi = requestApi; exports.createFetchGuid = createFetchGuid; exports.destroySDK = destroySDK; exports.fetchGuid = fetchGuid; exports.getSDK = getSDK; exports.getWsSnapshot = getWsSnapshot; exports.initSDK = initSDK; exports.notify = notify; exports.requestApi = requestApi; exports.requestApiSpec = requestApi; exports.setUniqueKeyStorage = setUniqueKeyStorage; exports.webStorage = webStorage;
+
+exports.adapters = adapters; exports.apiError = apiError; exports.callApi = requestApi; exports.createFetchGuid = createFetchGuid; exports.destroySDK = destroySDK; exports.fetchGuid = fetchGuid; exports.getSDK = getSDK; exports.getWsSnapshot = getWsSnapshot; exports.initSDK = initSDK; exports.notify = notify; exports.requestApi = requestApi; exports.requestApiSpec = requestApi; exports.setUniqueKeyStorage = setUniqueKeyStorage; exports.webStorage = webStorage;
 //# sourceMappingURL=index.cjs.map