@djvlc/openapi-client-core 1.2.0 → 1.2.1

package/dist/index.mjs

@@ -11697,44 +11697,2103 @@ var require_follow_redirects = __commonJS({
   }
 });
 
-// src/errors.ts
-var ApiError = class extends Error {
-  constructor(response, statusCode) {
-    super(response.message);
-    this.name = "ApiError";
-    this.code = response.code;
-    this.statusCode = statusCode;
-    this.details = response.details;
-    this.requestId = response.requestId;
-    this.traceId = response.traceId;
-    this.retryable = this.isRetryable(statusCode, response.code);
-  }
-  isRetryable(statusCode, code) {
-    if (statusCode >= 500 && statusCode < 600) {
+// src/types/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 3,
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffStrategy: "exponential",
+  retryableStatusCodes: [429, 500, 502, 503, 504],
+  retryOnNetworkError: true,
+  retryOnTimeout: true,
+  respectRetryAfter: true,
+  jitterFactor: 0.1
+};
+
+// src/types/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+
+// src/errors/base-error.ts
+var BaseClientError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    this.timestamp = /* @__PURE__ */ new Date();
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+  /**
+   * 转换为 JSON 对象（用于日志和序列化）
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      type: this.type,
+      message: this.message,
+      retryable: this.retryable,
+      timestamp: this.timestamp.toISOString(),
+      stack: this.stack
+    };
+  }
+  /**
+   * 转换为字符串
+   */
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+};
+
+// src/errors/api-error.ts
+var ApiError = class _ApiError extends BaseClientError {
+  constructor(config) {
+    super(config.message);
+    this.type = "API_ERROR";
+    this.code = config.code;
+    this.statusCode = config.statusCode;
+    this.details = config.details;
+    this.requestId = config.requestId;
+    this.traceId = config.traceId;
+    this.retryAfterSeconds = config.retryAfter;
+    this.rawResponse = config.rawResponse;
+  }
+  /**
+   * 是否可重试
+   *
+   * 5xx 和 429 错误通常可重试
+   */
+  get retryable() {
+    if (this.statusCode === 429) {
+      return true;
+    }
+    if (this.statusCode >= 500 && this.statusCode < 600 && this.statusCode !== 501) {
+      return true;
+    }
+    return false;
+  }
+  // ============================================================
+  // 状态码判断方法
+  // ============================================================
+  /**
+   * 是否为未授权错误 (401)
+   */
+  isUnauthorized() {
+    return this.statusCode === 401;
+  }
+  /**
+   * 是否为禁止访问错误 (403)
+   */
+  isForbidden() {
+    return this.statusCode === 403;
+  }
+  /**
+   * 是否为认证相关错误 (401/403)
+   */
+  isAuthError() {
+    return this.isUnauthorized() || this.isForbidden();
+  }
+  /**
+   * 是否为未找到错误 (404)
+   */
+  isNotFound() {
+    return this.statusCode === 404;
+  }
+  /**
+   * 是否为冲突错误 (409)
+   */
+  isConflict() {
+    return this.statusCode === 409;
+  }
+  /**
+   * 是否为验证错误 (400/422)
+   */
+  isValidationError() {
+    return this.statusCode === 400 || this.statusCode === 422;
+  }
+  /**
+   * 是否为限流错误 (429)
+   */
+  isRateLimited() {
+    return this.statusCode === 429;
+  }
+  /**
+   * 是否为客户端错误 (4xx)
+   */
+  isClientError() {
+    return this.statusCode >= 400 && this.statusCode < 500;
+  }
+  /**
+   * 是否为服务端错误 (5xx)
+   */
+  isServerError() {
+    return this.statusCode >= 500 && this.statusCode < 600;
+  }
+  // ============================================================
+  // 重试相关方法
+  // ============================================================
+  /**
+   * 获取 Retry-After 值（秒）
+   */
+  getRetryAfter() {
+    return this.retryAfterSeconds;
+  }
+  /**
+   * 获取推荐的重试延迟（毫秒）
+   *
+   * @param defaultMs - 默认延迟（毫秒）
+   */
+  getRetryDelayMs(defaultMs = 1e3) {
+    if (this.retryAfterSeconds !== void 0) {
+      return this.retryAfterSeconds * 1e3;
+    }
+    return defaultMs;
+  }
+  // ============================================================
+  // 序列化
+  // ============================================================
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      code: this.code,
+      statusCode: this.statusCode,
+      details: this.details,
+      requestId: this.requestId,
+      traceId: this.traceId,
+      retryAfterSeconds: this.retryAfterSeconds
+    };
+  }
+  // ============================================================
+  // 静态方法
+  // ============================================================
+  /**
+   * 类型守卫：判断是否为 ApiError
+   */
+  static is(error) {
+    return error instanceof _ApiError;
+  }
+  /**
+   * 从响应数据创建 ApiError
+   */
+  static fromResponse(data, statusCode, retryAfter) {
+    return new _ApiError({
+      message: data.message ?? `HTTP Error ${statusCode}`,
+      code: data.code ?? `HTTP_${statusCode}`,
+      statusCode,
+      details: data.details,
+      requestId: data.requestId ?? "unknown",
+      traceId: data.traceId,
+      retryAfter,
+      rawResponse: data
+    });
+  }
+};
+
+// src/errors/network-error.ts
+var NetworkError = class _NetworkError extends BaseClientError {
+  constructor(message, cause) {
+    super(message);
+    this.type = "NETWORK_ERROR";
+    this.retryable = true;
+    this.cause = cause;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      cause: this.cause ? {
+        name: this.cause.name,
+        message: this.cause.message
+      } : void 0
+    };
+  }
+  /**
+   * 类型守卫：判断是否为 NetworkError
+   */
+  static is(error) {
+    return error instanceof _NetworkError;
+  }
+  /**
+   * 从原生 fetch 错误创建 NetworkError
+   */
+  static fromFetchError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("network") || message.includes("failed to fetch")) {
+      return new _NetworkError("Network request failed", error);
+    }
+    if (message.includes("dns") || message.includes("getaddrinfo")) {
+      return new _NetworkError("DNS resolution failed", error);
+    }
+    if (message.includes("connection refused") || message.includes("econnrefused")) {
+      return new _NetworkError("Connection refused", error);
+    }
+    if (message.includes("connection reset") || message.includes("econnreset")) {
+      return new _NetworkError("Connection reset", error);
+    }
+    if (message.includes("ssl") || message.includes("certificate")) {
+      return new _NetworkError("SSL/TLS error", error);
+    }
+    return new _NetworkError(error.message || "Unknown network error", error);
+  }
+};
+
+// src/errors/timeout-error.ts
+var TimeoutError = class _TimeoutError extends BaseClientError {
+  constructor(timeoutMs) {
+    super(`Request timeout after ${timeoutMs}ms`);
+    this.type = "TIMEOUT_ERROR";
+    this.retryable = true;
+    this.timeoutMs = timeoutMs;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      timeoutMs: this.timeoutMs
+    };
+  }
+  /**
+   * 类型守卫：判断是否为 TimeoutError
+   */
+  static is(error) {
+    return error instanceof _TimeoutError;
+  }
+};
+
+// src/errors/abort-error.ts
+var AbortError = class _AbortError extends BaseClientError {
+  constructor(reason) {
+    super(reason ?? "Request was aborted");
+    this.type = "ABORT_ERROR";
+    this.retryable = false;
+    this.reason = reason;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      reason: this.reason
+    };
+  }
+  /**
+   * 类型守卫：判断是否为 AbortError
+   */
+  static is(error) {
+    return error instanceof _AbortError;
+  }
+  /**
+   * 从原生 AbortError 创建
+   */
+  static fromNative(error) {
+    return new _AbortError(error.message);
+  }
+};
+
+// src/errors/index.ts
+function isRetryableError(error) {
+  if (error instanceof ApiError || error instanceof NetworkError || error instanceof TimeoutError) {
+    return error.retryable;
+  }
+  if (error instanceof AbortError) {
+    return false;
+  }
+  return false;
+}
+function getRetryDelay(error, defaultMs = 1e3) {
+  if (error instanceof ApiError) {
+    return error.getRetryDelayMs(defaultMs);
+  }
+  return defaultMs;
+}
+function isClientError(error) {
+  return error instanceof ApiError || error instanceof NetworkError || error instanceof TimeoutError || error instanceof AbortError;
+}
+function getErrorType(error) {
+  if (error instanceof ApiError) {
+    return error.type;
+  }
+  if (error instanceof NetworkError) {
+    return error.type;
+  }
+  if (error instanceof TimeoutError) {
+    return error.type;
+  }
+  if (error instanceof AbortError) {
+    return error.type;
+  }
+  if (error instanceof Error) {
+    return error.name;
+  }
+  return "UNKNOWN_ERROR";
+}
+
+// src/auth/bearer-authenticator.ts
+var BearerAuthenticator = class {
+  constructor(config) {
+    this.type = "bearer";
+    this.getToken = config.getToken;
+    this.headerName = config.headerName ?? "Authorization";
+    this.prefix = config.prefix ?? "Bearer";
+  }
+  async authenticate(headers) {
+    const token = await this.getToken();
+    if (token !== null && token !== "") {
+      headers[this.headerName] = `${this.prefix} ${token}`;
+    }
+  }
+};
+function createBearerAuthenticator(config) {
+  return new BearerAuthenticator(config);
+}
+
+// src/auth/api-key-authenticator.ts
+var ApiKeyAuthenticator = class {
+  constructor(config) {
+    this.type = "api-key";
+    this.apiKey = config.apiKey;
+    this.headerName = config.headerName ?? "X-API-Key";
+  }
+  authenticate(headers) {
+    headers[this.headerName] = this.apiKey;
+  }
+};
+function createApiKeyAuthenticator(config) {
+  return new ApiKeyAuthenticator(config);
+}
+
+// src/auth/basic-authenticator.ts
+function encodeBase64(str) {
+  if (typeof btoa !== "undefined") {
+    const utf8Bytes = new TextEncoder().encode(str);
+    const binaryString = Array.from(utf8Bytes, (byte) => String.fromCharCode(byte)).join("");
+    return btoa(binaryString);
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(str, "utf-8").toString("base64");
+  }
+  throw new Error("Base64 encoding is not supported in this environment");
+}
+var BasicAuthenticator = class {
+  constructor(config) {
+    this.type = "basic";
+    this.encodedCredentials = encodeBase64(`${config.username}:${config.password}`);
+  }
+  authenticate(headers) {
+    headers["Authorization"] = `Basic ${this.encodedCredentials}`;
+  }
+};
+function createBasicAuthenticator(config) {
+  return new BasicAuthenticator(config);
+}
+
+// src/auth/custom-authenticator.ts
+var CustomAuthenticator = class {
+  constructor(config) {
+    this.type = "custom";
+    this.authenticateFn = config.authenticate;
+  }
+  async authenticate(headers) {
+    await this.authenticateFn(headers);
+  }
+};
+function createCustomAuthenticator(config) {
+  return new CustomAuthenticator(config);
+}
+
+// src/auth/no-authenticator.ts
+var NoAuthenticator = class {
+  constructor() {
+    this.type = "none";
+  }
+  authenticate(_headers) {
+  }
+};
+function createNoAuthenticator() {
+  return new NoAuthenticator();
+}
+var noAuthenticator = new NoAuthenticator();
+
+// src/auth/index.ts
+function createAuthenticatorFromConfig(config) {
+  switch (config.type) {
+    case "bearer":
+      return new BearerAuthenticator({ getToken: config.getToken, headerName: config.headerName, prefix: config.prefix });
+    case "api-key":
+      return new ApiKeyAuthenticator({ apiKey: config.apiKey, headerName: config.headerName });
+    case "basic":
+      return new BasicAuthenticator({ username: config.username, password: config.password });
+    case "custom":
+      return new CustomAuthenticator({ authenticate: config.authenticate });
+    case "none":
+      return noAuthenticator;
+    default: {
+      const _exhaustiveCheck = config;
+      throw new Error(`Unknown auth type: ${_exhaustiveCheck.type}`);
+    }
+  }
+}
+
+// src/interceptors/manager.ts
+var InterceptorManager = class {
+  constructor() {
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    this.errorInterceptors = [];
+  }
+  /**
+   * 获取所有拦截器
+   */
+  get interceptors() {
+    return {
+      request: [...this.requestInterceptors],
+      response: [...this.responseInterceptors],
+      error: [...this.errorInterceptors]
+    };
+  }
+  // ============================================================
+  // 注册方法
+  // ============================================================
+  /**
+   * 添加请求拦截器
+   *
+   * @param interceptor - 请求拦截器
+   * @returns 返回自身，支持链式调用
+   */
+  addRequestInterceptor(interceptor) {
+    this.requestInterceptors.push(interceptor);
+    this.sortInterceptors(this.requestInterceptors);
+    return this;
+  }
+  /**
+   * 添加响应拦截器
+   *
+   * @param interceptor - 响应拦截器
+   * @returns 返回自身，支持链式调用
+   */
+  addResponseInterceptor(interceptor) {
+    this.responseInterceptors.push(interceptor);
+    this.sortInterceptors(this.responseInterceptors);
+    return this;
+  }
+  /**
+   * 添加错误拦截器
+   *
+   * @param interceptor - 错误拦截器
+   * @returns 返回自身，支持链式调用
+   */
+  addErrorInterceptor(interceptor) {
+    this.errorInterceptors.push(interceptor);
+    this.sortInterceptors(this.errorInterceptors);
+    return this;
+  }
+  /**
+   * 批量添加拦截器
+   *
+   * @param interceptors - 拦截器配置
+   * @returns 返回自身，支持链式调用
+   */
+  addInterceptors(interceptors) {
+    if (interceptors.request) {
+      for (const i of interceptors.request) {
+        this.addRequestInterceptor(i);
+      }
+    }
+    if (interceptors.response) {
+      for (const i of interceptors.response) {
+        this.addResponseInterceptor(i);
+      }
+    }
+    if (interceptors.error) {
+      for (const i of interceptors.error) {
+        this.addErrorInterceptor(i);
+      }
+    }
+    return this;
+  }
+  // ============================================================
+  // 移除方法
+  // ============================================================
+  /**
+   * 移除请求拦截器
+   *
+   * @param name - 拦截器名称
+   * @returns 是否移除成功
+   */
+  removeRequestInterceptor(name) {
+    return this.removeByName(this.requestInterceptors, name);
+  }
+  /**
+   * 移除响应拦截器
+   *
+   * @param name - 拦截器名称
+   * @returns 是否移除成功
+   */
+  removeResponseInterceptor(name) {
+    return this.removeByName(this.responseInterceptors, name);
+  }
+  /**
+   * 移除错误拦截器
+   *
+   * @param name - 拦截器名称
+   * @returns 是否移除成功
+   */
+  removeErrorInterceptor(name) {
+    return this.removeByName(this.errorInterceptors, name);
+  }
+  /**
+   * 清除所有拦截器
+   */
+  clear() {
+    this.requestInterceptors.length = 0;
+    this.responseInterceptors.length = 0;
+    this.errorInterceptors.length = 0;
+  }
+  // ============================================================
+  // 执行方法
+  // ============================================================
+  /**
+   * 执行请求拦截器链
+   *
+   * @param context - 请求上下文
+   * @returns 修改后的请求选项
+   */
+  async executeRequestInterceptors(context) {
+    let options = context.options;
+    for (const interceptor of this.requestInterceptors) {
+      options = await interceptor.intercept({
+        ...context,
+        options
+      });
+    }
+    return options;
+  }
+  /**
+   * 执行响应拦截器链
+   *
+   * @param response - 响应数据
+   * @param context - 请求上下文
+   * @returns 修改后的响应数据
+   */
+  async executeResponseInterceptors(response, context) {
+    let result = response;
+    for (const interceptor of this.responseInterceptors) {
+      result = await interceptor.intercept(result, context);
+    }
+    return result;
+  }
+  /**
+   * 执行错误拦截器链
+   *
+   * @param error - 错误对象
+   * @param context - 请求上下文
+   * @returns 如果返回 ResponseData，则表示错误被恢复；否则错误继续传播
+   * @throws 如果拦截器抛出新错误，则使用新错误
+   */
+  async executeErrorInterceptors(error, context) {
+    for (const interceptor of this.errorInterceptors) {
+      const result = await interceptor.intercept(error, context);
+      if (result !== void 0) {
+        return result;
+      }
+    }
+    return void 0;
+  }
+  // ============================================================
+  // 私有方法
+  // ============================================================
+  /**
+   * 按 order 排序拦截器
+   */
+  sortInterceptors(interceptors) {
+    interceptors.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  /**
+   * 按名称移除拦截器
+   */
+  removeByName(interceptors, name) {
+    const index = interceptors.findIndex((i) => i.name === name);
+    if (index !== -1) {
+      interceptors.splice(index, 1);
       return true;
     }
-    if (statusCode === 429) {
-      return true;
+    return false;
+  }
+};
+function createInterceptorManager() {
+  return new InterceptorManager();
+}
+
+// src/interceptors/request/auth.interceptor.ts
+var AuthInterceptor = class {
+  constructor(config) {
+    this.name = "auth";
+    this.authenticator = config.authenticator;
+    this.order = config.order ?? -100;
+  }
+  async intercept(context) {
+    const { options } = context;
+    if (options.skipAuth) {
+      return options;
+    }
+    await this.authenticator.authenticate(options.headers);
+    return options;
+  }
+};
+function createAuthInterceptor(config) {
+  return new AuthInterceptor(config);
+}
+
+// src/utils/request-id.ts
+function generateRequestId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 9);
+  return `req_${timestamp}_${random}`;
+}
+function generateTraceId() {
+  const timestamp = Date.now().toString(36);
+  const random1 = Math.random().toString(36).slice(2, 9);
+  const random2 = Math.random().toString(36).slice(2, 9);
+  return `trace_${timestamp}_${random1}_${random2}`;
+}
+function isValidRequestId(id) {
+  return /^req_[a-z0-9]+_[a-z0-9]+$/.test(id);
+}
+function isValidTraceId(id) {
+  return /^trace_[a-z0-9]+_[a-z0-9]+_[a-z0-9]+$/.test(id);
+}
+
+// src/interceptors/request/request-id.interceptor.ts
+var RequestIdInterceptor = class {
+  constructor(config = {}) {
+    this.name = "request-id";
+    this.headerName = config.headerName ?? "X-Request-ID";
+    this.generateId = config.generateId ?? generateRequestId;
+    this.order = config.order ?? -90;
+  }
+  intercept(context) {
+    const { options } = context;
+    if (!options.headers[this.headerName]) {
+      options.headers[this.headerName] = context.requestId;
+    }
+    return options;
+  }
+};
+function createRequestIdInterceptor(config) {
+  return new RequestIdInterceptor(config);
+}
+
+// src/interceptors/request/trace.interceptor.ts
+var TraceInterceptor = class {
+  constructor(config = {}) {
+    this.name = "trace";
+    this.traceIdHeader = config.traceIdHeader ?? "X-Trace-ID";
+    this.addTraceparent = config.addTraceparent ?? false;
+    this.getTraceId = config.getTraceId;
+    this.getTraceparent = config.getTraceparent;
+    this.order = config.order ?? -80;
+  }
+  intercept(context) {
+    const { options } = context;
+    if (!options.headers[this.traceIdHeader]) {
+      const traceId = this.getTraceId?.() ?? context.traceId ?? generateTraceId();
+      options.headers[this.traceIdHeader] = traceId;
+    }
+    if (this.addTraceparent && this.getTraceparent) {
+      const traceparent = this.getTraceparent();
+      if (traceparent && !options.headers["traceparent"]) {
+        options.headers["traceparent"] = traceparent;
+      }
+    }
+    return options;
+  }
+};
+function createTraceInterceptor(config) {
+  return new TraceInterceptor(config);
+}
+
+// src/interceptors/request/timeout.interceptor.ts
+var TimeoutInterceptor = class {
+  constructor(config = {}) {
+    this.name = "timeout";
+    this.defaultTimeout = config.defaultTimeout ?? 3e4;
+    this.methodTimeouts = config.methodTimeouts ?? {};
+    this.pathTimeouts = config.pathTimeouts ?? [];
+    this.order = config.order ?? -70;
+  }
+  intercept(context) {
+    const { options } = context;
+    if (options.timeout !== void 0) {
+      return options;
+    }
+    for (const { pattern, timeout } of this.pathTimeouts) {
+      if (pattern.test(options.path)) {
+        options.timeout = timeout;
+        return options;
+      }
+    }
+    const methodTimeout = this.methodTimeouts[options.method];
+    if (methodTimeout !== void 0) {
+      options.timeout = methodTimeout;
+      return options;
+    }
+    options.timeout = this.defaultTimeout;
+    return options;
+  }
+};
+function createTimeoutInterceptor(config) {
+  return new TimeoutInterceptor(config);
+}
+
+// src/utils/retry-delay.ts
+function calculateRetryDelay(config, attempt) {
+  const baseDelay = calculateBaseDelay(config.backoffStrategy, config.initialDelayMs, attempt);
+  const jitterFactor = config.jitterFactor ?? 0.1;
+  const delayWithJitter = addJitter(baseDelay, jitterFactor);
+  return Math.min(delayWithJitter, config.maxDelayMs);
+}
+function calculateBaseDelay(strategy, initialDelayMs, attempt) {
+  switch (strategy) {
+    case "fixed":
+      return initialDelayMs;
+    case "linear":
+      return initialDelayMs * (attempt + 1);
+    case "exponential":
+      return initialDelayMs * Math.pow(2, attempt);
+    default: {
+      const _exhaustiveCheck = strategy;
+      throw new Error(`Unknown backoff strategy: ${_exhaustiveCheck}`);
+    }
+  }
+}
+function addJitter(delay, factor) {
+  const validFactor = Math.max(0, Math.min(1, factor));
+  const jitterRange = delay * validFactor;
+  const jitter = (Math.random() - 0.5) * 2 * jitterRange;
+  return Math.max(0, delay + jitter);
+}
+function parseRetryAfter(retryAfter) {
+  if (!retryAfter) {
+    return void 0;
+  }
+  const seconds = parseInt(retryAfter, 10);
+  if (!isNaN(seconds) && seconds >= 0) {
+    return seconds;
+  }
+  const date = new Date(retryAfter);
+  if (!isNaN(date.getTime())) {
+    const delayMs = date.getTime() - Date.now();
+    return Math.max(0, Math.ceil(delayMs / 1e3));
+  }
+  return void 0;
+}
+function getRecommendedRetryDelay(config, attempt, retryAfterSeconds) {
+  if (config.respectRetryAfter !== false && retryAfterSeconds !== void 0) {
+    const retryAfterMs = retryAfterSeconds * 1e3;
+    return Math.min(retryAfterMs, config.maxDelayMs);
+  }
+  return calculateRetryDelay(config, attempt);
+}
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function sleepWithAbort(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      resolve();
+    }, ms);
+    if (signal) {
+      const abortHandler = () => {
+        clearTimeout(timeoutId);
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+  });
+}
+
+// src/interceptors/response/retry.interceptor.ts
+var RetryInterceptor = class {
+  constructor(config) {
+    this.name = "retry";
+    this.config = {
+      ...DEFAULT_RETRY_CONFIG,
+      maxRetries: config.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
+      initialDelayMs: config.initialDelayMs ?? DEFAULT_RETRY_CONFIG.initialDelayMs,
+      maxDelayMs: config.maxDelayMs ?? DEFAULT_RETRY_CONFIG.maxDelayMs,
+      backoffStrategy: config.backoffStrategy ?? DEFAULT_RETRY_CONFIG.backoffStrategy,
+      retryableStatusCodes: config.retryableStatusCodes ?? DEFAULT_RETRY_CONFIG.retryableStatusCodes,
+      retryOnNetworkError: config.retryOnNetworkError ?? DEFAULT_RETRY_CONFIG.retryOnNetworkError,
+      retryOnTimeout: config.retryOnTimeout ?? DEFAULT_RETRY_CONFIG.retryOnTimeout,
+      respectRetryAfter: config.respectRetryAfter ?? DEFAULT_RETRY_CONFIG.respectRetryAfter,
+      jitterFactor: config.jitterFactor ?? DEFAULT_RETRY_CONFIG.jitterFactor,
+      onRetry: config.onRetry,
+      shouldRetry: config.shouldRetry
+    };
+    this.executeRequest = config.executeRequest;
+    this.order = config.order ?? 100;
+  }
+  async intercept(error, context) {
+    if (!this.shouldRetry(error, context)) {
+      return void 0;
+    }
+    const retryAfterSeconds = error instanceof ApiError ? error.getRetryAfter() : void 0;
+    const delayMs = getRecommendedRetryDelay(this.config, context.retryCount, retryAfterSeconds);
+    if (this.config.onRetry) {
+      const retryInfo = {
+        attempt: context.retryCount + 1,
+        maxRetries: this.config.maxRetries,
+        delayMs,
+        error,
+        url: context.url,
+        method: context.options.method
+      };
+      this.config.onRetry(retryInfo);
+    }
+    await sleep(delayMs);
+    context.retryCount++;
+    return this.executeRequest(context);
+  }
+  /**
+   * 判断是否应该重试
+   */
+  shouldRetry(error, context) {
+    if (context.retryCount >= this.config.maxRetries) {
+      return false;
+    }
+    if (error instanceof AbortError) {
+      return false;
+    }
+    if (this.config.shouldRetry) {
+      const statusCode = error instanceof ApiError ? error.statusCode : void 0;
+      const retryAfter = error instanceof ApiError ? error.getRetryAfter() : void 0;
+      return this.config.shouldRetry(error, context.retryCount, {
+        url: context.url,
+        method: context.options.method,
+        statusCode,
+        retryAfter
+      });
+    }
+    if (error instanceof NetworkError) {
+      return this.config.retryOnNetworkError !== false;
+    }
+    if (error instanceof TimeoutError) {
+      return this.config.retryOnTimeout !== false;
+    }
+    if (error instanceof ApiError) {
+      const retryableCodes = this.config.retryableStatusCodes ?? [];
+      return retryableCodes.includes(error.statusCode);
+    }
+    return false;
+  }
+};
+function createRetryInterceptor(config) {
+  return new RetryInterceptor(config);
+}
+
+// src/interceptors/response/token-refresh.interceptor.ts
+var TokenRefreshInterceptor = class {
+  constructor(config) {
+    this.name = "token-refresh";
+    this.state = {
+      isRefreshing: false,
+      refreshPromise: null,
+      failCount: 0
+    };
+    this.refreshToken = config.refreshToken;
+    this.executeRequest = config.executeRequest;
+    this.triggerStatusCodes = config.triggerStatusCodes ?? [401];
+    this.maxRetries = config.maxRetries ?? 1;
+    this.onTokenRefreshed = config.onTokenRefreshed;
+    this.onRefreshFailed = config.onRefreshFailed;
+    this.order = config.order ?? 50;
+  }
+  async intercept(error, context) {
+    if (!(error instanceof ApiError)) {
+      return void 0;
+    }
+    if (!this.shouldRefresh(error, context)) {
+      return void 0;
+    }
+    try {
+      const newToken = await this.doRefresh();
+      this.onTokenRefreshed?.(newToken);
+      this.state.failCount = 0;
+      return this.executeRequest(context);
+    } catch (refreshError) {
+      this.state.failCount++;
+      this.onRefreshFailed?.(refreshError);
+      return void 0;
+    }
+  }
+  /**
+   * 判断是否应该刷新 Token
+   */
+  shouldRefresh(error, context) {
+    if (!this.triggerStatusCodes.includes(error.statusCode)) {
+      return false;
+    }
+    if (this.state.failCount >= this.maxRetries) {
+      return false;
+    }
+    if (context.metadata["tokenRefreshAttempted"]) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 执行 Token 刷新
+   *
+   * 合并并发请求，确保同一时间只有一个刷新请求
+   */
+  async doRefresh() {
+    if (this.state.isRefreshing && this.state.refreshPromise) {
+      return this.state.refreshPromise;
+    }
+    this.state.isRefreshing = true;
+    this.state.refreshPromise = this.refreshToken();
+    try {
+      const newToken = await this.state.refreshPromise;
+      return newToken;
+    } finally {
+      this.state.isRefreshing = false;
+      this.state.refreshPromise = null;
+    }
+  }
+  /**
+   * 重置状态（用于测试或手动重置）
+   */
+  reset() {
+    this.state.isRefreshing = false;
+    this.state.refreshPromise = null;
+    this.state.failCount = 0;
+  }
+};
+function createTokenRefreshInterceptor(config) {
+  return new TokenRefreshInterceptor(config);
+}
+
+// src/interceptors/response/error-transform.interceptor.ts
+var ErrorTransformInterceptor = class {
+  constructor(config = {}) {
+    this.name = "error-transform";
+    this.includeRawResponse = config.includeRawResponse ?? false;
+    this.extractErrorMessage = config.extractErrorMessage;
+    this.extractErrorCode = config.extractErrorCode;
+    this.order = config.order ?? 0;
+  }
+  intercept(response, _context) {
+    return response;
+  }
+};
+function createErrorTransformInterceptor(config) {
+  return new ErrorTransformInterceptor(config);
+}
+
+// src/interceptors/error/logging.interceptor.ts
+var LoggingInterceptor = class {
+  constructor(config) {
+    this.name = "logging";
+    this.logger = config.logger;
+    this.verbose = config.verbose ?? false;
+    this.logAborted = config.logAborted ?? false;
+    this.filter = config.filter;
+    this.order = config.order ?? -100;
+  }
+  intercept(error, context) {
+    if (this.filter && !this.filter(error, context)) {
+      return void 0;
+    }
+    if (error instanceof AbortError && !this.logAborted) {
+      return void 0;
+    }
+    const logInfo = this.buildLogInfo(error, context);
+    if (error instanceof ApiError && error.isClientError() && !error.isRateLimited()) {
+      this.logger.warn(`[API Error] ${logInfo.summary}`, logInfo);
+    } else if (error instanceof AbortError) {
+      this.logger.debug(`[Aborted] ${logInfo.summary}`, logInfo);
+    } else {
+      this.logger.error(`[Error] ${logInfo.summary}`, logInfo);
+    }
+    return void 0;
+  }
+  /**
+   * 构建日志信息
+   */
+  buildLogInfo(error, context) {
+    const duration = Date.now() - context.startTime;
+    const base = {
+      summary: `${context.options.method} ${context.options.path} - ${error.message}`,
+      requestId: context.requestId,
+      traceId: context.traceId,
+      method: context.options.method,
+      path: context.options.path,
+      url: context.url,
+      duration: `${duration}ms`,
+      retryCount: context.retryCount
+    };
+    if (this.verbose) {
+      const detailed = {
+        ...base,
+        error: {
+          name: error.name,
+          message: error.message,
+          stack: error.stack
+        }
+      };
+      if (error instanceof ApiError) {
+        detailed.apiError = {
+          code: error.code,
+          statusCode: error.statusCode,
+          details: error.details,
+          retryable: error.retryable
+        };
+      } else if (error instanceof TimeoutError) {
+        detailed.timeout = error.timeoutMs;
+      } else if (error instanceof NetworkError) {
+        detailed.networkError = error.cause?.message;
+      }
+      return detailed;
+    }
+    if (error instanceof ApiError) {
+      return {
+        ...base,
+        code: error.code,
+        statusCode: error.statusCode
+      };
+    }
+    if (error instanceof TimeoutError) {
+      return {
+        ...base,
+        timeout: error.timeoutMs
+      };
+    }
+    return base;
+  }
+};
+function createLoggingInterceptor(config) {
+  return new LoggingInterceptor(config);
+}
+
+// src/interceptors/error/reporting.interceptor.ts
+var ReportingInterceptor = class {
+  constructor(config) {
+    this.name = "reporting";
+    this.reporter = config.reporter;
+    this.getSeverity = config.getSeverity ?? this.defaultGetSeverity;
+    this.reportClientErrors = config.reportClientErrors ?? false;
+    this.reportAborted = config.reportAborted ?? false;
+    this.reportNetworkErrors = config.reportNetworkErrors ?? true;
+    this.sampleRate = config.sampleRate ?? 1;
+    this.extractContext = config.extractContext;
+    this.order = config.order ?? -50;
+  }
+  intercept(error, context) {
+    if (!this.shouldReport(error)) {
+      return void 0;
+    }
+    if (this.sampleRate < 1 && Math.random() > this.sampleRate) {
+      return void 0;
+    }
+    const reportContext = this.buildReportContext(error, context);
+    try {
+      this.reporter.report(error, reportContext);
+    } catch {
+    }
+    return void 0;
+  }
+  /**
+   * 判断是否应该上报
+   */
+  shouldReport(error) {
+    if (error instanceof AbortError) {
+      return this.reportAborted;
+    }
+    if (error instanceof NetworkError) {
+      return this.reportNetworkErrors;
+    }
+    if (error instanceof ApiError) {
+      if (error.isClientError()) {
+        return this.reportClientErrors;
+      }
+      return true;
+    }
+    if (error instanceof TimeoutError) {
+      return true;
+    }
+    return true;
+  }
+  /**
+   * 构建上报上下文
+   */
+  buildReportContext(error, context) {
+    const baseContext = {
+      severity: this.getSeverity(error),
+      requestId: context.requestId,
+      traceId: context.traceId,
+      url: context.url,
+      method: context.options.method,
+      path: context.options.path,
+      retryCount: context.retryCount,
+      duration: Date.now() - context.startTime
+    };
+    if (error instanceof ApiError) {
+      baseContext["api"] = {
+        code: error.code,
+        statusCode: error.statusCode,
+        retryable: error.retryable
+      };
+    } else if (error instanceof TimeoutError) {
+      baseContext["timeout"] = error.timeoutMs;
+    }
+    if (this.extractContext) {
+      const customContext = this.extractContext(error, context);
+      return { ...baseContext, ...customContext };
+    }
+    return baseContext;
+  }
+  /**
+   * 默认的严重程度判断
+   */
+  defaultGetSeverity(error) {
+    if (error instanceof AbortError) {
+      return "debug";
+    }
+    if (error instanceof ApiError) {
+      if (error.isServerError()) {
+        return "error";
+      }
+      if (error.isRateLimited()) {
+        return "warning";
+      }
+      return "info";
+    }
+    if (error instanceof NetworkError || error instanceof TimeoutError) {
+      return "warning";
+    }
+    return "error";
+  }
+};
+function createReportingInterceptor(config) {
+  return new ReportingInterceptor(config);
+}
+
+// src/plugins/deduplication.ts
+var RequestDeduper = class {
+  constructor(config = {}) {
+    this.inflightRequests = /* @__PURE__ */ new Map();
+    this.getOnly = config.getOnly ?? true;
+    this.generateKey = config.generateKey ?? this.defaultGenerateKey;
+    this.maxSize = config.maxSize ?? 100;
+  }
+  /**
+   * 执行请求（带去重）
+   *
+   * @param method - HTTP 方法
+   * @param url - 请求 URL
+   * @param execute - 实际执行请求的函数
+   * @returns 请求结果
+   */
+  async execute(method, url2, execute) {
+    if (!this.shouldDeduplicate(method)) {
+      return execute();
+    }
+    const key = this.generateKey(method, url2);
+    const inflight = this.inflightRequests.get(key);
+    if (inflight) {
+      return inflight.promise;
+    }
+    if (this.inflightRequests.size >= this.maxSize) {
+      this.cleanup();
+    }
+    const promise = execute().finally(() => {
+      this.inflightRequests.delete(key);
+    });
+    this.inflightRequests.set(key, {
+      promise,
+      createdAt: Date.now()
+    });
+    return promise;
+  }
+  /**
+   * 包装 fetch 函数
+   *
+   * @param fetch - 原始 fetch 函数
+   * @returns 去重的 fetch 函数
+   */
+  wrap(fetch2) {
+    return (url2, init) => {
+      const method = init?.method ?? "GET";
+      return this.execute(method, url2, () => fetch2(url2, init));
+    };
+  }
+  /**
+   * 获取当前飞行中的请求数量
+   */
+  get inflightCount() {
+    return this.inflightRequests.size;
+  }
+  /**
+   * 清空所有飞行中的请求
+   */
+  clear() {
+    this.inflightRequests.clear();
+  }
+  /**
+   * 判断是否应该去重
+   */
+  shouldDeduplicate(method) {
+    if (this.getOnly) {
+      return method.toUpperCase() === "GET";
+    }
+    return true;
+  }
+  /**
+   * 默认的键生成函数
+   */
+  defaultGenerateKey(method, url2) {
+    return `${method.toUpperCase()}:${url2}`;
+  }
+  /**
+   * 清理过期的请求
+   */
+  cleanup() {
+    const toDelete = Math.floor(this.maxSize * 0.2);
+    const entries = Array.from(this.inflightRequests.entries()).sort((a, b) => a[1].createdAt - b[1].createdAt);
+    for (let i = 0; i < toDelete && i < entries.length; i++) {
+      this.inflightRequests.delete(entries[i][0]);
+    }
+  }
+};
+function createRequestDeduper(config) {
+  return new RequestDeduper(config);
+}
+
+// src/utils/url.ts
+function buildUrl(baseUrl, path, query) {
+  const normalizedBase = baseUrl.replace(/\/+$/, "");
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const url2 = new URL(`${normalizedBase}${normalizedPath}`);
+  if (query) {
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0 && value !== null) {
+        url2.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url2.toString();
+}
+function extractPath(url2) {
+  try {
+    const parsed = new URL(url2);
+    return parsed.pathname;
+  } catch {
+    const queryIndex = url2.indexOf("?");
+    const pathPart = queryIndex >= 0 ? url2.slice(0, queryIndex) : url2;
+    return pathPart.startsWith("/") ? pathPart : `/${pathPart}`;
+  }
+}
+function parseQueryString(queryString) {
+  const result = {};
+  const normalized = queryString.startsWith("?") ? queryString.slice(1) : queryString;
+  if (!normalized) {
+    return result;
+  }
+  const params = new URLSearchParams(normalized);
+  for (const [key, value] of params.entries()) {
+    result[key] = value;
+  }
+  return result;
+}
+function joinPaths(base, path) {
+  const normalizedBase = base.replace(/\/+$/, "");
+  const normalizedPath = path.replace(/^\/+/, "");
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return `${normalizedBase}/${normalizedPath}`;
+}
+
+// src/plugins/metrics.ts
+var DefaultMetricsCollector = class {
+  constructor(config = {}) {
+    this.metrics = [];
+    this.maxMetrics = config.maxMetrics ?? 1e3;
+    this.ttlMs = config.ttlMs ?? 36e5;
+    this.onMetrics = config.onMetrics;
+  }
+  record(metrics) {
+    this.onMetrics?.(metrics);
+    this.metrics.push(metrics);
+    this.cleanup();
+  }
+  summary() {
+    if (this.metrics.length === 0) {
+      return this.emptySummary();
+    }
+    const successful = this.metrics.filter((m) => m.success);
+    const durations = this.metrics.map((m) => m.durationMs).sort((a, b) => a - b);
+    const p = (percentile) => {
+      const index = Math.ceil(durations.length * percentile / 100) - 1;
+      return durations[Math.max(0, index)];
+    };
+    const statusCodeDistribution = {};
+    for (const m of this.metrics) {
+      if (m.status !== void 0) {
+        statusCodeDistribution[m.status] = (statusCodeDistribution[m.status] ?? 0) + 1;
+      }
+    }
+    const pathDistribution = {};
+    const pathGroups = {};
+    for (const m of this.metrics) {
+      if (!pathGroups[m.path]) {
+        pathGroups[m.path] = [];
+      }
+      pathGroups[m.path].push(m);
+    }
+    for (const [path, group] of Object.entries(pathGroups)) {
+      const successCount = group.filter((m) => m.success).length;
+      const avgDuration2 = group.reduce((sum, m) => sum + m.durationMs, 0) / group.length;
+      pathDistribution[path] = {
+        count: group.length,
+        successCount,
+        avgDurationMs: Math.round(avgDuration2)
+      };
+    }
+    const totalRetries = this.metrics.reduce((sum, m) => sum + m.retryCount, 0);
+    const avgDuration = this.metrics.reduce((sum, m) => sum + m.durationMs, 0) / this.metrics.length;
+    return {
+      totalRequests: this.metrics.length,
+      successfulRequests: successful.length,
+      failedRequests: this.metrics.length - successful.length,
+      successRate: successful.length / this.metrics.length,
+      avgDurationMs: Math.round(avgDuration),
+      p50Ms: p(50),
+      p90Ms: p(90),
+      p95Ms: p(95),
+      p99Ms: p(99),
+      minDurationMs: durations[0],
+      maxDurationMs: durations[durations.length - 1],
+      totalRetries,
+      statusCodeDistribution,
+      pathDistribution
+    };
+  }
+  getAll() {
+    return [...this.metrics];
+  }
+  getByPath(path) {
+    return this.metrics.filter((m) => m.path === path);
+  }
+  flush() {
+    const result = [...this.metrics];
+    this.metrics = [];
+    return result;
+  }
+  clear() {
+    this.metrics = [];
+  }
+  cleanup() {
+    const now = Date.now();
+    this.metrics = this.metrics.filter((m) => now - m.startTime < this.ttlMs);
+    while (this.metrics.length > this.maxMetrics) {
+      this.metrics.shift();
+    }
+  }
+  emptySummary() {
+    return {
+      totalRequests: 0,
+      successfulRequests: 0,
+      failedRequests: 0,
+      successRate: 0,
+      avgDurationMs: 0,
+      p50Ms: 0,
+      p90Ms: 0,
+      p95Ms: 0,
+      p99Ms: 0,
+      minDurationMs: 0,
+      maxDurationMs: 0,
+      totalRetries: 0,
+      statusCodeDistribution: {},
+      pathDistribution: {}
+    };
+  }
+};
+function createMetricsCollector(config) {
+  return new DefaultMetricsCollector(config);
+}
+var MetricsRequestInterceptor = class {
+  constructor() {
+    this.name = "metrics-request";
+    this.order = -1e3;
+  }
+  // 最先执行
+  intercept(context) {
+    return context.options;
+  }
+};
+var MetricsResponseInterceptor = class {
+  // 最后执行
+  constructor(collector) {
+    this.collector = collector;
+    this.name = "metrics-response";
+    this.order = 1e3;
+  }
+  intercept(response, context) {
+    const endTime = Date.now();
+    const metrics = {
+      requestId: context.requestId,
+      url: context.url,
+      path: extractPath(context.url),
+      method: context.options.method,
+      startTime: context.startTime,
+      endTime,
+      durationMs: endTime - context.startTime,
+      status: response.status,
+      success: true,
+      retryCount: context.retryCount,
+      traceId: context.traceId
+    };
+    this.collector.record(metrics);
+    return response;
+  }
+};
+var MetricsErrorInterceptor = class {
+  // 最后执行
+  constructor(collector) {
+    this.collector = collector;
+    this.name = "metrics-error";
+    this.order = 1e3;
+  }
+  intercept(error, context) {
+    const endTime = Date.now();
+    const metrics = {
+      requestId: context.requestId,
+      url: context.url,
+      path: extractPath(context.url),
+      method: context.options.method,
+      startTime: context.startTime,
+      endTime,
+      durationMs: endTime - context.startTime,
+      success: false,
+      retryCount: context.retryCount,
+      traceId: context.traceId,
+      error: error.message
+    };
+    this.collector.record(metrics);
+    return void 0;
+  }
+};
+function createMetricsInterceptors(collector) {
+  return {
+    request: new MetricsRequestInterceptor(),
+    response: new MetricsResponseInterceptor(collector),
+    error: new MetricsErrorInterceptor(collector)
+  };
+}
+
+// src/plugins/logger.ts
+var ConsoleLogger = class {
+  constructor(config = {}) {
+    this.prefix = config.prefix ?? "[DJV-API]";
+    this.level = config.level ?? "info";
+    this.timestamp = config.timestamp ?? true;
+    this.levelPriority = LOG_LEVEL_PRIORITY[this.level];
+  }
+  debug(message, ...args) {
+    this.log("debug", message, args);
+  }
+  info(message, ...args) {
+    this.log("info", message, args);
+  }
+  warn(message, ...args) {
+    this.log("warn", message, args);
+  }
+  error(message, ...args) {
+    this.log("error", message, args);
+  }
+  log(level, message, args) {
+    if (LOG_LEVEL_PRIORITY[level] < this.levelPriority) {
+      return;
+    }
+    const formattedMessage = this.formatMessage(level, message);
+    switch (level) {
+      case "debug":
+        console.debug(formattedMessage, ...args);
+        break;
+      case "info":
+        console.info(formattedMessage, ...args);
+        break;
+      case "warn":
+        console.warn(formattedMessage, ...args);
+        break;
+      case "error":
+        console.error(formattedMessage, ...args);
+        break;
+    }
+  }
+  formatMessage(level, message) {
+    const parts = [];
+    if (this.timestamp) {
+      parts.push(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
+    }
+    parts.push(this.prefix);
+    parts.push(`[${level.toUpperCase()}]`);
+    parts.push(message);
+    return parts.join(" ");
+  }
+};
+function createConsoleLogger(config) {
+  return new ConsoleLogger(config);
+}
+var SilentLogger = class {
+  debug(_message, ..._args) {
+  }
+  info(_message, ..._args) {
+  }
+  warn(_message, ..._args) {
+  }
+  error(_message, ..._args) {
+  }
+};
+function createSilentLogger() {
+  return new SilentLogger();
+}
+var silentLogger = new SilentLogger();
+var BufferLogger = class {
+  constructor(maxSize = 1e3) {
+    this.buffer = [];
+    this.maxSize = maxSize;
+  }
+  debug(message, ...args) {
+    this.add("debug", message, args);
+  }
+  info(message, ...args) {
+    this.add("info", message, args);
+  }
+  warn(message, ...args) {
+    this.add("warn", message, args);
+  }
+  error(message, ...args) {
+    this.add("error", message, args);
+  }
+  /**
+   * 获取所有日志
+   */
+  getLogs() {
+    return [...this.buffer];
+  }
+  /**
+   * 获取指定级别的日志
+   */
+  getLogsByLevel(level) {
+    return this.buffer.filter((log) => log.level === level);
+  }
+  /**
+   * 清空日志
+   */
+  clear() {
+    this.buffer.length = 0;
+  }
+  /**
+   * 获取日志数量
+   */
+  get size() {
+    return this.buffer.length;
+  }
+  add(level, message, args) {
+    this.buffer.push({
+      level,
+      message,
+      args,
+      timestamp: /* @__PURE__ */ new Date()
+    });
+    while (this.buffer.length > this.maxSize) {
+      this.buffer.shift();
+    }
+  }
+};
+function createBufferLogger(maxSize) {
+  return new BufferLogger(maxSize);
+}
+
+// src/utils/headers.ts
+var DEFAULT_HEADERS = {
+  "Content-Type": "application/json",
+  Accept: "application/json"
+};
+function mergeHeaders(...headersList) {
+  const result = {};
+  const lowercaseKeyMap = {};
+  for (const headers of headersList) {
+    if (!headers) continue;
+    for (const [key, value] of Object.entries(headers)) {
+      const lowercaseKey = key.toLowerCase();
+      if (lowercaseKeyMap[lowercaseKey]) {
+        delete result[lowercaseKeyMap[lowercaseKey]];
+      }
+      result[key] = value;
+      lowercaseKeyMap[lowercaseKey] = key;
+    }
+  }
+  return result;
+}
+function getHeader(headers, name) {
+  const lowercaseName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowercaseName) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function setHeader(headers, name, value) {
+  const lowercaseName = name.toLowerCase();
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === lowercaseName) {
+      delete headers[key];
+    }
+  }
+  headers[name] = value;
+}
+function removeHeader(headers, name) {
+  const lowercaseName = name.toLowerCase();
+  let removed = false;
+  for (const key of Object.keys(headers)) {
+    if (key.toLowerCase() === lowercaseName) {
+      delete headers[key];
+      removed = true;
+    }
+  }
+  return removed;
+}
+function extractResponseHeaders(response) {
+  const headers = {};
+  response.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return headers;
+}
+function hasContentType(headers, contentType) {
+  const value = getHeader(headers, "Content-Type");
+  if (!value) return false;
+  return value.toLowerCase().includes(contentType.toLowerCase());
+}
+
+// src/clients/base-client.ts
+var BaseClient = class {
+  constructor(config) {
+    this.config = {
+      timeout: 3e4,
+      ...config
+    };
+    this.interceptorManager = new InterceptorManager();
+    this.authenticator = config.auth ? createAuthenticatorFromConfig(config.auth) : noAuthenticator;
+    this.registerConfigInterceptors();
+  }
+  /**
+   * GET 请求
+   */
+  async get(path, query) {
+    return this.request({ method: "GET", path, query });
+  }
+  /**
+   * POST 请求
+   */
+  async post(path, body, query) {
+    return this.request({ method: "POST", path, body, query });
+  }
+  /**
+   * PUT 请求
+   */
+  async put(path, body) {
+    return this.request({ method: "PUT", path, body });
+  }
+  /**
+   * PATCH 请求
+   */
+  async patch(path, body) {
+    return this.request({ method: "PATCH", path, body });
+  }
+  /**
+   * DELETE 请求
+   */
+  async delete(path) {
+    return this.request({ method: "DELETE", path });
+  }
+  /**
+   * 获取拦截器管理器
+   */
+  get interceptors() {
+    return this.interceptorManager;
+  }
+  /**
+   * 创建请求上下文
+   */
+  createRequestContext(options) {
+    const requestId = generateRequestId();
+    const traceId = generateTraceId();
+    const url2 = buildUrl(this.config.baseUrl, options.path, options.query);
+    const headers = mergeHeaders(
+      DEFAULT_HEADERS,
+      this.config.headers,
+      options.headers
+    );
+    const mutableOptions = {
+      method: options.method,
+      path: options.path,
+      query: options.query ? { ...options.query } : void 0,
+      body: options.body,
+      headers,
+      timeout: options.timeout ?? this.config.timeout,
+      skipAuth: options.skipAuth ?? false,
+      signal: options.signal,
+      metadata: options.metadata ? { ...options.metadata } : {}
+    };
+    return {
+      requestId,
+      traceId,
+      startTime: Date.now(),
+      retryCount: 0,
+      originalOptions: options,
+      options: mutableOptions,
+      url: url2,
+      metadata: {}
+    };
+  }
+  /**
+   * 执行请求拦截器
+   */
+  async runRequestInterceptors(context) {
+    if (!context.options.skipAuth) {
+      await this.authenticator.authenticate(context.options.headers);
+    }
+    return this.interceptorManager.executeRequestInterceptors(context);
+  }
+  /**
+   * 执行响应拦截器
+   */
+  async runResponseInterceptors(response, context) {
+    return this.interceptorManager.executeResponseInterceptors(response, context);
+  }
+  /**
+   * 执行错误拦截器
+   */
+  async runErrorInterceptors(error, context) {
+    return this.interceptorManager.executeErrorInterceptors(error, context);
+  }
+  /**
+   * 注册配置中的拦截器
+   */
+  registerConfigInterceptors() {
+    if (this.config.requestInterceptors) {
+      for (const interceptor of this.config.requestInterceptors) {
+        this.interceptorManager.addRequestInterceptor(interceptor);
+      }
+    }
+    if (this.config.responseInterceptors) {
+      for (const interceptor of this.config.responseInterceptors) {
+        this.interceptorManager.addResponseInterceptor(interceptor);
+      }
+    }
+    if (this.config.errorInterceptors) {
+      for (const interceptor of this.config.errorInterceptors) {
+        this.interceptorManager.addErrorInterceptor(interceptor);
+      }
+    }
+  }
+};
+
+// src/clients/fetch-client.ts
+var FetchClient = class extends BaseClient {
+  constructor(config) {
+    super(config);
+    this.enableRetry = config.enableRetry !== false;
+  }
+  /**
+   * 发起请求
+   */
+  async request(options) {
+    const context = this.createRequestContext(options);
+    try {
+      const response = await this.executeWithRetry(context);
+      return response.data;
+    } catch (error) {
+      const recovered = await this.runErrorInterceptors(error, context);
+      if (recovered) {
+        return recovered.data;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 带重试的请求执行
+   */
+  async executeWithRetry(context) {
+    const retryConfig = this.config.retry;
+    const maxRetries = this.enableRetry && retryConfig ? retryConfig.maxRetries : 0;
+    for (; ; ) {
+      try {
+        return await this.executeRequest(context);
+      } catch (error) {
+        const err = error;
+        if (!this.shouldRetry(err, context, retryConfig, maxRetries)) {
+          throw err;
+        }
+        const retryAfterSeconds = err instanceof ApiError ? err.getRetryAfter() : void 0;
+        let delayMs = calculateRetryDelay(retryConfig, context.retryCount);
+        if (retryConfig?.respectRetryAfter !== false && retryAfterSeconds !== void 0) {
+          delayMs = Math.min(retryAfterSeconds * 1e3, retryConfig.maxDelayMs);
+        }
+        if (retryConfig?.onRetry) {
+          retryConfig.onRetry({
+            attempt: context.retryCount + 1,
+            maxRetries: retryConfig.maxRetries,
+            delayMs,
+            error: err,
+            url: context.url,
+            method: context.options.method
+          });
+        }
+        this.logDebug(
+          `[Retry] ${context.options.method} ${context.options.path} - attempt ${context.retryCount + 1}/${maxRetries}, delay ${delayMs}ms`
+        );
+        await sleep(delayMs);
+        context.retryCount++;
+      }
+    }
+  }
+  /**
+   * 判断是否应该重试
+   */
+  shouldRetry(error, context, retryConfig, maxRetries) {
+    if (!this.enableRetry || !retryConfig) {
+      return false;
+    }
+    if (context.retryCount >= maxRetries) {
+      return false;
+    }
+    if (error instanceof AbortError) {
+      return false;
+    }
+    if (retryConfig.shouldRetry) {
+      const statusCode = error instanceof ApiError ? error.statusCode : void 0;
+      const retryAfter = error instanceof ApiError ? error.getRetryAfter() : void 0;
+      return retryConfig.shouldRetry(error, context.retryCount, {
+        url: context.url,
+        method: context.options.method,
+        statusCode,
+        retryAfter
+      });
+    }
+    if (error instanceof NetworkError) {
+      return retryConfig.retryOnNetworkError !== false;
+    }
+    if (error instanceof TimeoutError) {
+      return retryConfig.retryOnTimeout !== false;
+    }
+    if (error instanceof ApiError) {
+      const retryableCodes = retryConfig.retryableStatusCodes ?? DEFAULT_RETRY_CONFIG.retryableStatusCodes;
+      return retryableCodes?.includes(error.statusCode) ?? false;
+    }
+    return false;
+  }
+  /**
+   * 执行单次请求
+   */
+  async executeRequest(context) {
+    const options = await this.runRequestInterceptors(context);
+    context.options = options;
+    const url2 = this.buildFullUrl(context);
+    const init = this.buildFetchInit(context);
+    const { signal, cleanup } = this.createTimeoutSignal(
+      options.timeout ?? 3e4,
+      options.signal
+    );
+    this.logDebug(`[Request] ${options.method} ${url2}`, {
+      requestId: context.requestId,
+      headers: options.headers
+    });
+    try {
+      const fetchResponse = await fetch(url2, {
+        ...init,
+        signal
+      });
+      const response = await this.parseResponse(fetchResponse, context);
+      const duration = Date.now() - context.startTime;
+      this.logDebug(
+        `[Response] ${options.method} ${options.path} - ${fetchResponse.status} (${duration}ms)`,
+        { requestId: context.requestId, status: fetchResponse.status, duration }
+      );
+      return this.runResponseInterceptors(response, context);
+    } catch (error) {
+      const transformedError = this.transformError(error, context);
+      const duration = Date.now() - context.startTime;
+      this.logError(
+        `[Error] ${options.method} ${options.path} - ${transformedError.message} (${duration}ms)`,
+        { requestId: context.requestId, error: transformedError.message, duration }
+      );
+      throw transformedError;
+    } finally {
+      cleanup();
+    }
+  }
+  /**
+   * 构建完整 URL
+   */
+  buildFullUrl(context) {
+    const { options } = context;
+    const base = this.config.baseUrl.replace(/\/+$/, "");
+    const path = options.path.startsWith("/") ? options.path : `/${options.path}`;
+    const url2 = new URL(`${base}${path}`);
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0 && value !== null) {
+          url2.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url2.toString();
+  }
+  /**
+   * 构建 fetch init 对象
+   */
+  buildFetchInit(context) {
+    const { options } = context;
+    const init = {
+      method: options.method,
+      headers: options.headers
+    };
+    if (options.body !== void 0) {
+      init.body = JSON.stringify(options.body);
+    }
+    return init;
+  }
+  /**
+   * 创建超时信号
+   */
+  createTimeoutSignal(timeoutMs, externalSignal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort(new DOMException(`Timeout of ${timeoutMs}ms exceeded`, "TimeoutError"));
+    }, timeoutMs);
+    if (externalSignal) {
+      if (externalSignal.aborted) {
+        controller.abort(externalSignal.reason);
+      } else {
+        const onAbort = () => {
+          controller.abort(externalSignal.reason);
+        };
+        externalSignal.addEventListener("abort", onAbort, { once: true });
+      }
+    }
+    return {
+      signal: controller.signal,
+      cleanup: () => {
+        if (timeoutId !== void 0) {
+          clearTimeout(timeoutId);
+        }
+      }
+    };
+  }
+  /**
+   * 解析响应
+   */
+  async parseResponse(fetchResponse, context) {
+    const headers = extractResponseHeaders(fetchResponse);
+    let data;
+    try {
+      data = await fetchResponse.json();
+    } catch {
+      if (!fetchResponse.ok) {
+        throw ApiError.fromResponse(
+          {
+            code: `HTTP_${fetchResponse.status}`,
+            message: fetchResponse.statusText || `HTTP Error ${fetchResponse.status}`,
+            requestId: context.requestId
+          },
+          fetchResponse.status,
+          parseRetryAfter(getHeader(headers, "Retry-After"))
+        );
+      }
+      data = {
+        success: true,
+        data: void 0,
+        requestId: context.requestId
+      };
+    }
+    if (!fetchResponse.ok || data.success === false) {
+      throw ApiError.fromResponse(
+        {
+          code: data.code,
+          message: data.message,
+          details: data.details,
+          requestId: data.requestId ?? context.requestId,
+          traceId: data.traceId ?? context.traceId
+        },
+        fetchResponse.status,
+        parseRetryAfter(getHeader(headers, "Retry-After"))
+      );
+    }
+    return {
+      data: data.data,
+      status: fetchResponse.status,
+      statusText: fetchResponse.statusText,
+      headers,
+      requestId: data.requestId ?? context.requestId,
+      traceId: data.traceId ?? context.traceId
+    };
+  }
+  /**
+   * 转换错误
+   */
+  transformError(error, _context) {
+    if (error instanceof ApiError || error instanceof NetworkError || error instanceof TimeoutError || error instanceof AbortError) {
+      return error;
+    }
+    if (error.name === "AbortError") {
+      if (error.message?.includes("Timeout")) {
+        const match = error.message.match(/(\d+)ms/);
+        const timeout = match ? parseInt(match[1], 10) : 3e4;
+        return new TimeoutError(timeout);
+      }
+      return AbortError.fromNative(error);
+    }
+    if (error.name === "TypeError") {
+      return NetworkError.fromFetchError(error);
     }
-    const retryableCodes = ["SYSTEM_TIMEOUT", "SYSTEM_SERVICE_UNAVAILABLE"];
-    return retryableCodes.includes(code);
+    return new NetworkError(error.message, error);
   }
-};
-var NetworkError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.retryable = true;
-    this.name = "NetworkError";
+  // ============================================================
+  // 日志辅助方法
+  // ============================================================
+  /**
+   * 调试日志
+   */
+  logDebug(message, data) {
+    if (this.config.debug && this.config.logger) {
+      this.config.logger.debug(message, data);
+    }
   }
-};
-var TimeoutError = class extends Error {
-  constructor(timeout) {
-    super(`Request timeout after ${timeout}ms`);
-    this.retryable = true;
-    this.name = "TimeoutError";
+  /**
+   * 错误日志
+   */
+  logError(message, data) {
+    if (this.config.logger) {
+      this.config.logger.error(message, data);
+    }
   }
 };
+function createFetchClient(config) {
+  return new FetchClient(config);
+}
 
 // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
@@ -12391,7 +14450,7 @@ function buildURL(url2, params, options) {
 }
 
 // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/core/InterceptorManager.js
-var InterceptorManager = class {
+var InterceptorManager2 = class {
   constructor() {
     this.handlers = [];
   }
@@ -12452,7 +14511,7 @@ var InterceptorManager = class {
     });
   }
 };
-var InterceptorManager_default = InterceptorManager;
+var InterceptorManager_default = InterceptorManager2;
 
 // ../../node_modules/.pnpm/axios@1.13.2/node_modules/axios/lib/defaults/transitional.js
 var transitional_default = {
@@ -12801,7 +14860,7 @@ var AxiosHeaders = class {
   }
   set(header, valueOrRewrite, rewrite) {
     const self2 = this;
-    function setHeader(_value, _header, _rewrite) {
+    function setHeader2(_value, _header, _rewrite) {
       const lHeader = normalizeHeader(_header);
       if (!lHeader) {
         throw new Error("header name must be a non-empty string");
@@ -12811,7 +14870,7 @@ var AxiosHeaders = class {
         self2[key || _header] = normalizeValue(_value);
       }
     }
-    const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+    const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader2(_value, _header, _rewrite));
     if (utils_default.isPlainObject(header) || header instanceof this.constructor) {
       setHeaders(header, valueOrRewrite);
     } else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
@@ -12826,7 +14885,7 @@ var AxiosHeaders = class {
       }
       setHeaders(obj, valueOrRewrite);
     } else {
-      header != null && setHeader(valueOrRewrite, header, rewrite);
+      header != null && setHeader2(valueOrRewrite, header, rewrite);
     }
     return this;
   }
@@ -14585,7 +16644,7 @@ var factory = (env2) => {
   const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder2()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
   const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
     let duplexAccessed = false;
-    const hasContentType = new Request(platform_default.origin, {
+    const hasContentType2 = new Request(platform_default.origin, {
       body: new ReadableStream2(),
       method: "POST",
       get duplex() {
@@ -14593,7 +16652,7 @@ var factory = (env2) => {
         return "half";
       }
     }).headers.has("Content-Type");
-    return duplexAccessed && !hasContentType;
+    return duplexAccessed && !hasContentType2;
   });
   const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
   const resolvers = {
@@ -15347,113 +17406,7 @@ var {
   mergeConfig: mergeConfig2
 } = axios_default;
 
-// src/auth.ts
-async function addAuthToAxiosConfig(config, auth) {
-  switch (auth.type) {
-    case "bearer": {
-      if (auth.getToken) {
-        const token = typeof auth.getToken === "function" ? await auth.getToken() : auth.getToken;
-        if (token) {
-          config.headers.set("Authorization", `Bearer ${token}`);
-        }
-      }
-      break;
-    }
-    case "api-key": {
-      if (auth.apiKey) {
-        const headerName = auth.apiKeyHeader ?? "X-API-Key";
-        config.headers.set(headerName, auth.apiKey);
-      }
-      break;
-    }
-    case "basic": {
-      if (auth.username && auth.password) {
-        const encoded = btoa(`${auth.username}:${auth.password}`);
-        config.headers.set("Authorization", `Basic ${encoded}`);
-      }
-      break;
-    }
-    case "custom": {
-      if (auth.customAuth) {
-        const headers = {};
-        await auth.customAuth(headers);
-        Object.entries(headers).forEach(([key, value]) => {
-          config.headers.set(key, value);
-        });
-      }
-      break;
-    }
-  }
-}
-async function addAuthToHeaders(headers, auth) {
-  switch (auth.type) {
-    case "bearer": {
-      if (auth.getToken) {
-        const token = typeof auth.getToken === "function" ? await auth.getToken() : auth.getToken;
-        if (token) {
-          headers["Authorization"] = `Bearer ${token}`;
-        }
-      }
-      break;
-    }
-    case "api-key": {
-      if (auth.apiKey) {
-        const headerName = auth.apiKeyHeader ?? "X-API-Key";
-        headers[headerName] = auth.apiKey;
-      }
-      break;
-    }
-    case "basic": {
-      if (auth.username && auth.password) {
-        const encoded = btoa(`${auth.username}:${auth.password}`);
-        headers["Authorization"] = `Basic ${encoded}`;
-      }
-      break;
-    }
-    case "custom": {
-      if (auth.customAuth) {
-        await auth.customAuth(headers);
-      }
-      break;
-    }
-  }
-}
-
-// src/utils.ts
-function generateRequestId() {
-  return `req_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 9)}`;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function calculateRetryDelay(retry, attempt) {
-  let delay;
-  switch (retry.backoff) {
-    case "fixed":
-      delay = retry.initialDelay;
-      break;
-    case "linear":
-      delay = retry.initialDelay * (attempt + 1);
-      break;
-    case "exponential":
-    default:
-      delay = retry.initialDelay * Math.pow(2, attempt);
-      break;
-  }
-  const jitter = delay * 0.1 * Math.random();
-  delay += jitter;
-  return Math.min(delay, retry.maxDelay);
-}
-
-// src/axios-instance.ts
-function shouldRetryAxios(error, retry) {
-  if (!error.response) {
-    return retry.retryOnNetworkError !== false;
-  }
-  const status = error.response.status;
-  const retryableCodes = retry.retryableStatusCodes ?? [429, 500, 502, 503, 504];
-  return retryableCodes.includes(status);
-}
+// src/clients/axios-client.ts
 function createAxiosInstance(config) {
   const instance = axios_default.create({
     baseURL: config.baseUrl,
@@ -15464,247 +17417,643 @@ function createAxiosInstance(config) {
       ...config.headers
     }
   });
+  const authenticator = config.auth ? createAuthenticatorFromConfig(config.auth) : noAuthenticator;
+  const logger = config.logger;
+  const debug = config.debug ?? false;
   instance.interceptors.request.use(
     async (axiosConfig) => {
+      axiosConfig.__startTime = Date.now();
       const requestId = generateRequestId();
+      const traceId = generateTraceId();
+      axiosConfig.__requestId = requestId;
+      axiosConfig.__traceId = traceId;
       axiosConfig.headers.set("X-Request-ID", requestId);
-      if (config.auth) {
-        await addAuthToAxiosConfig(axiosConfig, config.auth);
+      axiosConfig.headers.set("X-Trace-ID", traceId);
+      const headers = {};
+      await authenticator.authenticate(headers);
+      for (const [key, value] of Object.entries(headers)) {
+        axiosConfig.headers.set(key, value);
+      }
+      if (config.requestInterceptors) {
+        await executeRequestInterceptors(config.requestInterceptors, axiosConfig);
+      }
+      if (debug && logger) {
+        logger.debug(`[Request] ${axiosConfig.method?.toUpperCase()} ${axiosConfig.url}`, {
+          requestId,
+          headers: Object.fromEntries(
+            Object.entries(axiosConfig.headers).filter(([, v]) => typeof v === "string")
+          )
+        });
       }
       return axiosConfig;
     },
     (error) => Promise.reject(error)
   );
   instance.interceptors.response.use(
-    (response) => response,
+    async (response) => {
+      const axiosConfig = response.config;
+      const duration = Date.now() - (axiosConfig.__startTime ?? Date.now());
+      if (debug && logger) {
+        logger.debug(
+          `[Response] ${axiosConfig.method?.toUpperCase()} ${axiosConfig.url} - ${response.status} (${duration}ms)`,
+          {
+            requestId: axiosConfig.__requestId,
+            status: response.status,
+            duration
+          }
+        );
+      }
+      if (config.responseInterceptors) {
+        await executeResponseInterceptors(config.responseInterceptors, response);
+      }
+      return response;
+    },
     async (error) => {
-      if (config.retry && shouldRetryAxios(error, config.retry)) {
-        const errorConfig = error.config;
-        const retryCount = errorConfig?.__retryCount ?? 0;
+      const axiosConfig = error.config;
+      const duration = Date.now() - (axiosConfig?.__startTime ?? Date.now());
+      const customError = transformAxiosError(error);
+      if (logger) {
+        logger.error(
+          `[Error] ${axiosConfig?.method?.toUpperCase()} ${axiosConfig?.url} - ${customError.message} (${duration}ms)`,
+          {
+            requestId: axiosConfig?.__requestId,
+            error: customError.message,
+            duration
+          }
+        );
+      }
+      if (config.errorInterceptors) {
+        const recovered = await executeErrorInterceptors(
+          config.errorInterceptors,
+          customError,
+          axiosConfig
+        );
+        if (recovered) {
+          return recovered;
+        }
+      }
+      if (config.enableRetry !== false && config.retry && shouldRetry(error, config.retry)) {
+        const retryCount = axiosConfig?.__retryCount ?? 0;
         if (retryCount < config.retry.maxRetries) {
-          const delay = calculateRetryDelay(config.retry, retryCount);
-          await sleep(delay);
-          if (errorConfig) {
-            errorConfig.__retryCount = retryCount + 1;
-            return instance.request(errorConfig);
+          let delayMs = calculateRetryDelay(config.retry, retryCount);
+          if (config.retry.respectRetryAfter !== false && error.response) {
+            const retryAfter = parseRetryAfter(
+              error.response.headers["retry-after"]
+            );
+            if (retryAfter !== void 0) {
+              delayMs = Math.min(retryAfter * 1e3, config.retry.maxDelayMs);
+            }
+          }
+          if (config.retry.onRetry) {
+            config.retry.onRetry({
+              attempt: retryCount + 1,
+              maxRetries: config.retry.maxRetries,
+              delayMs,
+              error: customError,
+              url: axiosConfig?.url ?? "",
+              method: axiosConfig?.method?.toUpperCase() ?? "GET"
+            });
+          }
+          if (debug && logger) {
+            logger.debug(
+              `[Retry] ${axiosConfig?.method?.toUpperCase()} ${axiosConfig?.url} - attempt ${retryCount + 1}/${config.retry.maxRetries}, delay ${delayMs}ms`
+            );
+          }
+          await sleep(delayMs);
+          if (axiosConfig) {
+            axiosConfig.__retryCount = retryCount + 1;
+            return instance.request(axiosConfig);
           }
         }
       }
-      return Promise.reject(error);
+      return Promise.reject(customError);
     }
   );
   return instance;
 }
-
-// src/http-client.ts
-var HttpClient = class {
-  constructor(config) {
-    this.config = {
-      timeout: 3e4,
-      headers: {},
-      ...config
+async function executeRequestInterceptors(interceptors, axiosConfig) {
+  const sorted = [...interceptors].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  for (const interceptor of sorted) {
+    const context = {
+      requestId: axiosConfig.__requestId ?? "",
+      traceId: axiosConfig.__traceId,
+      startTime: axiosConfig.__startTime ?? Date.now(),
+      retryCount: axiosConfig.__retryCount ?? 0,
+      originalOptions: {
+        method: axiosConfig.method?.toUpperCase() ?? "GET",
+        path: axiosConfig.url ?? ""
+      },
+      options: {
+        method: axiosConfig.method?.toUpperCase() ?? "GET",
+        path: axiosConfig.url ?? "",
+        headers: Object.fromEntries(
+          Object.entries(axiosConfig.headers).filter(([, v]) => typeof v === "string")
+        ),
+        body: axiosConfig.data,
+        timeout: axiosConfig.timeout,
+        metadata: {}
+      },
+      url: `${axiosConfig.baseURL ?? ""}${axiosConfig.url ?? ""}`,
+      metadata: {}
     };
+    const result = await interceptor.intercept(context);
+    if (result.headers) {
+      for (const [key, value] of Object.entries(result.headers)) {
+        axiosConfig.headers.set(key, value);
+      }
+    }
+    if (result.timeout !== void 0) {
+      axiosConfig.timeout = result.timeout;
+    }
   }
-  /**
-   * 发起请求
-   */
-  async request(options) {
-    let opts = { ...options };
-    for (const interceptor of this.config.onRequest || []) {
-      opts = await interceptor(opts);
-    }
-    const url2 = this.buildUrl(opts.path, opts.query);
-    const headers = await this.buildHeaders(opts);
-    const body = opts.body ? JSON.stringify(opts.body) : void 0;
-    const response = await this.executeWithRetry(
-      url2,
-      {
-        method: opts.method,
-        headers,
-        body,
-        timeout: opts.timeout || this.config.timeout
-      },
-      opts
-    );
-    return response;
+}
+async function executeResponseInterceptors(interceptors, response) {
+  const sorted = [...interceptors].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const axiosConfig = response.config;
+  for (const interceptor of sorted) {
+    const context = {
+      requestId: axiosConfig.__requestId ?? "",
+      traceId: axiosConfig.__traceId,
+      startTime: axiosConfig.__startTime ?? Date.now(),
+      retryCount: axiosConfig.__retryCount ?? 0,
+      originalOptions: {
+        method: axiosConfig.method?.toUpperCase() ?? "GET",
+        path: axiosConfig.url ?? ""
+      },
+      options: {
+        method: axiosConfig.method?.toUpperCase() ?? "GET",
+        path: axiosConfig.url ?? "",
+        headers: Object.fromEntries(
+          Object.entries(axiosConfig.headers).filter(([, v]) => typeof v === "string")
+        ),
+        body: axiosConfig.data,
+        timeout: axiosConfig.timeout,
+        metadata: {}
+      },
+      url: `${axiosConfig.baseURL ?? ""}${axiosConfig.url ?? ""}`,
+      metadata: {}
+    };
+    const responseData = {
+      data: response.data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      requestId: axiosConfig.__requestId ?? "",
+      traceId: axiosConfig.__traceId
+    };
+    await interceptor.intercept(responseData, context);
   }
-  /**
-   * GET 请求
-   */
-  async get(path, query) {
-    return this.request({ method: "GET", path, query });
+}
+async function executeErrorInterceptors(interceptors, error, axiosConfig) {
+  const sorted = [...interceptors].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  for (const interceptor of sorted) {
+    const context = {
+      requestId: axiosConfig?.__requestId ?? "",
+      traceId: axiosConfig?.__traceId,
+      startTime: axiosConfig?.__startTime ?? Date.now(),
+      retryCount: axiosConfig?.__retryCount ?? 0,
+      originalOptions: {
+        method: axiosConfig?.method?.toUpperCase() ?? "GET",
+        path: axiosConfig?.url ?? ""
+      },
+      options: {
+        method: axiosConfig?.method?.toUpperCase() ?? "GET",
+        path: axiosConfig?.url ?? "",
+        headers: axiosConfig ? Object.fromEntries(
+          Object.entries(axiosConfig.headers).filter(([, v]) => typeof v === "string")
+        ) : {},
+        body: axiosConfig?.data,
+        timeout: axiosConfig?.timeout,
+        metadata: {}
+      },
+      url: `${axiosConfig?.baseURL ?? ""}${axiosConfig?.url ?? ""}`,
+      metadata: {}
+    };
+    const result = await interceptor.intercept(error, context);
+    if (result !== void 0) {
+      return {
+        data: result.data,
+        status: result.status,
+        statusText: result.statusText,
+        headers: result.headers,
+        config: axiosConfig
+      };
+    }
   }
-  /**
-   * POST 请求
-   */
-  async post(path, body, query) {
-    return this.request({ method: "POST", path, body, query });
+  return void 0;
+}
+function shouldRetry(error, retry) {
+  if (!retry) return false;
+  if (!error.response) {
+    return retry.retryOnNetworkError !== false;
   }
-  /**
-   * PUT 请求
-   */
-  async put(path, body) {
-    return this.request({ method: "PUT", path, body });
+  const status = error.response.status;
+  const retryableCodes = retry.retryableStatusCodes ?? DEFAULT_RETRY_CONFIG.retryableStatusCodes;
+  return retryableCodes?.includes(status) ?? false;
+}
+function transformAxiosError(error) {
+  if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") {
+    const timeout = error.config?.timeout ?? 3e4;
+    return new TimeoutError(timeout);
   }
-  /**
-   * PATCH 请求
-   */
-  async patch(path, body) {
-    return this.request({ method: "PATCH", path, body });
+  if (!error.response) {
+    return new NetworkError(error.message, error);
   }
-  /**
-   * DELETE 请求
-   */
-  async delete(path) {
-    return this.request({ method: "DELETE", path });
+  const response = error.response;
+  const retryAfter = parseRetryAfter(
+    response.headers["retry-after"]
+  );
+  return ApiError.fromResponse(
+    {
+      code: response.data?.code,
+      message: response.data?.message ?? error.message,
+      details: response.data?.details,
+      requestId: response.data?.requestId ?? error.config?.headers?.["X-Request-ID"],
+      traceId: response.data?.traceId
+    },
+    response.status,
+    retryAfter
+  );
+}
+
+// src/clients/middleware-factory.ts
+function generateUniqueRequestKey() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+var REQUEST_KEY_HEADER = "X-Internal-Request-Key";
+var retryStateMap = /* @__PURE__ */ new Map();
+function getRequestKey(init) {
+  const headers = init.headers;
+  return headers?.[REQUEST_KEY_HEADER] ?? "";
+}
+function createMiddlewares(config = {}) {
+  const middlewares = [];
+  middlewares.push(createRequestMiddleware(config));
+  if (config.logger) {
+    middlewares.push(createLoggingMiddleware(config.logger, config.debug ?? false));
   }
-  /**
-   * 构建完整 URL
-   */
-  buildUrl(path, query) {
-    const base = this.config.baseUrl.replace(/\/$/, "");
-    const pathname = path.startsWith("/") ? path : `/${path}`;
-    const url2 = new URL(`${base}${pathname}`);
-    if (query) {
-      for (const [key, value] of Object.entries(query)) {
-        if (value !== void 0) {
-          url2.searchParams.set(key, String(value));
-        }
-      }
-    }
-    return url2.toString();
+  if (config.enableRetry !== false && config.retry) {
+    middlewares.push(createRetryMiddleware(config));
   }
-  /**
-   * 构建请求头
-   */
-  async buildHeaders(options) {
-    const headers = {
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      ...this.config.headers,
-      ...options.headers
-    };
-    if (options.context?.requestId) {
-      headers["X-Request-ID"] = options.context.requestId;
-    } else {
-      headers["X-Request-ID"] = generateRequestId();
+  if (config.preMiddlewares?.length) {
+    for (const preFn of config.preMiddlewares) {
+      middlewares.push({ pre: preFn });
     }
-    if (options.context?.traceId) {
-      headers["X-Trace-ID"] = options.context.traceId;
-    }
-    if (!options.skipAuth && this.config.auth) {
-      await addAuthToHeaders(headers, this.config.auth);
+  }
+  if (config.postMiddlewares?.length) {
+    for (const postFn of config.postMiddlewares) {
+      middlewares.push({ post: postFn });
     }
-    return headers;
   }
-  /**
-   * 带重试的请求执行
-   */
-  async executeWithRetry(url2, init, options) {
-    const retry = this.config.retry || {
-      maxRetries: 0,
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      backoff: "exponential"
-    };
-    let lastError;
-    let attempt = 0;
-    while (attempt <= retry.maxRetries) {
-      try {
-        return await this.execute(url2, init, options);
-      } catch (error) {
-        lastError = error;
-        const shouldRetry = this.shouldRetry(error, retry, attempt);
-        if (!shouldRetry) {
-          throw error;
-        }
-        const delay = calculateRetryDelay(retry, attempt);
-        await sleep(delay);
-        attempt++;
-      }
+  if (config.errorMiddlewares?.length) {
+    for (const errorFn of config.errorMiddlewares) {
+      middlewares.push({ onError: errorFn });
     }
-    throw lastError;
   }
-  /**
-   * 执行单次请求
-   */
-  async execute(url2, init, options) {
-    const controller = new AbortController();
-    const timeout = init.timeout || 3e4;
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    try {
-      const response = await fetch(url2, {
-        ...init,
-        signal: controller.signal
+  return middlewares;
+}
+function createRequestMiddleware(config) {
+  const authenticator = config.auth ? createAuthenticatorFromConfig(config.auth) : noAuthenticator;
+  return {
+    async pre(context) {
+      const requestId = generateRequestId();
+      const traceId = generateTraceId();
+      const requestKey = generateUniqueRequestKey();
+      retryStateMap.set(requestKey, {
+        attempt: 0,
+        startTime: Date.now(),
+        requestId,
+        traceId
       });
-      clearTimeout(timeoutId);
-      const data = await response.json();
-      if (!response.ok || !data.success) {
-        const errorResponse = {
-          success: false,
-          code: data.code || "UNKNOWN_ERROR",
-          message: data.message || "Unknown error",
-          requestId: data.requestId || generateRequestId(),
-          timestamp: data.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-          details: data.details,
-          traceId: data.traceId
-        };
-        const error = new ApiError(errorResponse, response.status);
-        for (const interceptor of this.config.onError || []) {
-          await interceptor(error, options);
+      const existingHeaders = context.init.headers ?? {};
+      const headers = {};
+      if (existingHeaders instanceof Headers) {
+        existingHeaders.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(existingHeaders)) {
+        for (const [key, value] of existingHeaders) {
+          headers[key] = value;
         }
-        throw error;
-      }
-      const successResponse = data;
-      for (const interceptor of this.config.onResponse || []) {
-        await interceptor(successResponse, options);
+      } else {
+        Object.assign(headers, existingHeaders);
+      }
+      headers[REQUEST_KEY_HEADER] = requestKey;
+      headers["X-Request-ID"] = requestId;
+      headers["X-Trace-ID"] = traceId;
+      if (config.headers) {
+        Object.assign(headers, config.headers);
+      }
+      await authenticator.authenticate(headers);
+      return {
+        url: context.url,
+        init: {
+          ...context.init,
+          headers
+        }
+      };
+    }
+  };
+}
+function createLoggingMiddleware(logger, debugMode) {
+  return {
+    async pre(context) {
+      if (!debugMode) return void 0;
+      const method = context.init.method ?? "GET";
+      const requestId = context.init.headers?.["X-Request-ID"] ?? "";
+      logger.debug(`[Request] ${method} ${context.url}`, { requestId });
+      return void 0;
+    },
+    async post(context) {
+      const requestKey = getRequestKey(context.init);
+      const state = retryStateMap.get(requestKey);
+      const duration = state ? Date.now() - state.startTime : 0;
+      if (requestKey) {
+        retryStateMap.delete(requestKey);
+      }
+      if (!debugMode) return void 0;
+      const method = context.init.method ?? "GET";
+      const requestId = context.init.headers?.["X-Request-ID"] ?? "";
+      logger.debug(`[Response] ${method} ${context.url} - ${context.response.status} (${duration}ms)`, {
+        requestId,
+        status: context.response.status,
+        duration
+      });
+      return void 0;
+    },
+    async onError(context) {
+      const method = context.init.method ?? "GET";
+      const requestId = context.init.headers?.["X-Request-ID"] ?? "";
+      const requestKey = getRequestKey(context.init);
+      const state = retryStateMap.get(requestKey);
+      const duration = state ? Date.now() - state.startTime : 0;
+      const errorMessage = context.error instanceof Error ? context.error.message : String(context.error);
+      logger.error(`[Error] ${method} ${context.url} - ${errorMessage} (${duration}ms)`, {
+        requestId,
+        error: errorMessage,
+        duration
+      });
+      return void 0;
+    }
+  };
+}
+function createRetryMiddleware(config) {
+  const retryConfig = config.retry;
+  const maxRetries = retryConfig.maxRetries;
+  const logger = config.logger;
+  const debug = config.debug ?? false;
+  return {
+    async onError(context) {
+      const requestKey = getRequestKey(context.init);
+      const state = retryStateMap.get(requestKey);
+      if (!state) {
+        return void 0;
+      }
+      if (!shouldRetry2(context.error, state.attempt, maxRetries, retryConfig)) {
+        retryStateMap.delete(requestKey);
+        return void 0;
+      }
+      state.attempt++;
+      const delay = calculateRetryDelay2(state.attempt, retryConfig);
+      if (retryConfig.onRetry) {
+        const method = context.init.method ?? "GET";
+        retryConfig.onRetry({
+          attempt: state.attempt,
+          maxRetries,
+          delayMs: delay,
+          error: context.error instanceof Error ? context.error : new Error(String(context.error)),
+          url: context.url,
+          method
+        });
       }
-      return successResponse.data;
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error instanceof ApiError) {
-        throw error;
+      if (debug && logger) {
+        const method = context.init.method ?? "GET";
+        logger.debug(`[Retry] ${method} ${context.url} - attempt ${state.attempt}/${maxRetries}, delay ${delay}ms`);
       }
-      if (error.name === "AbortError") {
-        throw new TimeoutError(timeout);
+      await sleep(delay);
+      try {
+        const response = await context.fetch(context.url, context.init);
+        if (!response.ok && shouldRetryStatus(response.status, state.attempt, maxRetries, retryConfig)) {
+          state.attempt++;
+          const nextDelay = calculateRetryDelay2(state.attempt, retryConfig);
+          if (debug && logger) {
+            const method = context.init.method ?? "GET";
+            logger.debug(`[Retry] ${method} ${context.url} - status ${response.status}, attempt ${state.attempt}/${maxRetries}, delay ${nextDelay}ms`);
+          }
+          await sleep(nextDelay);
+          return context.fetch(context.url, context.init);
+        }
+        retryStateMap.delete(requestKey);
+        return response;
+      } catch (retryError) {
+        if (state.attempt < maxRetries) {
+          throw retryError;
+        }
+        retryStateMap.delete(requestKey);
+        throw retryError;
       }
-      throw new NetworkError(error.message, error);
     }
+  };
+}
+function shouldRetry2(error, attempt, maxRetries, retryConfig) {
+  if (attempt >= maxRetries) return false;
+  if (error instanceof Error && error.name === "AbortError") {
+    return false;
   }
-  /**
-   * 判断是否应该重试
-   */
-  shouldRetry(error, retry, attempt) {
-    if (attempt >= retry.maxRetries) {
-      return false;
-    }
-    if (error instanceof TimeoutError || error instanceof NetworkError) {
-      return retry.retryOnNetworkError !== false;
+  if (error instanceof TypeError || error instanceof NetworkError) {
+    return retryConfig.retryOnNetworkError !== false;
+  }
+  if (error instanceof TimeoutError) {
+    return retryConfig.retryOnTimeout !== false;
+  }
+  return true;
+}
+function shouldRetryStatus(status, attempt, maxRetries, retryConfig) {
+  if (attempt >= maxRetries) return false;
+  const retryableCodes = retryConfig.retryableStatusCodes ?? [429, 500, 502, 503, 504];
+  return retryableCodes.includes(status);
+}
+function calculateRetryDelay2(attempt, retryConfig) {
+  const {
+    initialDelayMs = 1e3,
+    maxDelayMs = 3e4,
+    backoffStrategy = "exponential",
+    jitterFactor = 0.1
+  } = retryConfig;
+  let delay;
+  switch (backoffStrategy) {
+    case "fixed":
+      delay = initialDelayMs;
+      break;
+    case "linear":
+      delay = initialDelayMs * attempt;
+      break;
+    case "exponential":
+    default:
+      delay = initialDelayMs * Math.pow(2, attempt - 1);
+      break;
+  }
+  delay = Math.min(delay, maxDelayMs);
+  if (jitterFactor > 0) {
+    const jitter = delay * jitterFactor * (Math.random() * 2 - 1);
+    delay = Math.max(0, delay + jitter);
+  }
+  return Math.round(delay);
+}
+function createAuthMiddleware(authConfig) {
+  const authenticator = createAuthenticatorFromConfig(authConfig);
+  return {
+    async pre(context) {
+      const headers = {};
+      const existingHeaders = context.init.headers ?? {};
+      if (existingHeaders instanceof Headers) {
+        existingHeaders.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(existingHeaders)) {
+        for (const [key, value] of existingHeaders) {
+          headers[key] = value;
+        }
+      } else {
+        Object.assign(headers, existingHeaders);
+      }
+      await authenticator.authenticate(headers);
+      return {
+        url: context.url,
+        init: {
+          ...context.init,
+          headers
+        }
+      };
     }
-    if (error instanceof ApiError) {
-      const retryableCodes = retry.retryableStatusCodes || [429, 500, 502, 503, 504];
-      return error.retryable || retryableCodes.includes(error.statusCode);
+  };
+}
+function createTrackingMiddleware() {
+  return {
+    async pre(context) {
+      const requestId = generateRequestId();
+      const traceId = generateTraceId();
+      const headers = {};
+      const existingHeaders = context.init.headers ?? {};
+      if (existingHeaders instanceof Headers) {
+        existingHeaders.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(existingHeaders)) {
+        for (const [key, value] of existingHeaders) {
+          headers[key] = value;
+        }
+      } else {
+        Object.assign(headers, existingHeaders);
+      }
+      headers["X-Request-ID"] = requestId;
+      headers["X-Trace-ID"] = traceId;
+      return {
+        url: context.url,
+        init: {
+          ...context.init,
+          headers
+        }
+      };
     }
-    return false;
-  }
-};
-function createClient(config) {
-  return new HttpClient(config);
+  };
 }
 
 // src/index.ts
 var VERSION3 = "2.0.0";
+var SDK_NAME = "@djvlc/openapi-client-core";
+function getSdkInfo() {
+  return { name: SDK_NAME, version: VERSION3 };
+}
 export {
+  AbortError,
   ApiError,
-  HttpClient,
+  ApiKeyAuthenticator,
+  AuthInterceptor,
+  BaseClient,
+  BaseClientError,
+  BasicAuthenticator,
+  BearerAuthenticator,
+  BufferLogger,
+  ConsoleLogger,
+  CustomAuthenticator,
+  DEFAULT_HEADERS,
+  DEFAULT_RETRY_CONFIG,
+  DefaultMetricsCollector,
+  ErrorTransformInterceptor,
+  FetchClient,
+  InterceptorManager,
+  LOG_LEVEL_PRIORITY,
+  LoggingInterceptor,
+  MetricsErrorInterceptor,
+  MetricsRequestInterceptor,
+  MetricsResponseInterceptor,
   NetworkError,
+  NoAuthenticator,
+  ReportingInterceptor,
+  RequestDeduper,
+  RequestIdInterceptor,
+  RetryInterceptor,
+  SDK_NAME,
+  SilentLogger,
   TimeoutError,
+  TimeoutInterceptor,
+  TokenRefreshInterceptor,
+  TraceInterceptor,
   VERSION3 as VERSION,
+  buildUrl,
   calculateRetryDelay,
+  createApiKeyAuthenticator,
+  createAuthInterceptor,
+  createAuthMiddleware,
+  createAuthenticatorFromConfig,
   createAxiosInstance,
-  createClient,
+  createBasicAuthenticator,
+  createBearerAuthenticator,
+  createBufferLogger,
+  createConsoleLogger,
+  createCustomAuthenticator,
+  createErrorTransformInterceptor,
+  createFetchClient,
+  createInterceptorManager,
+  createLoggingInterceptor,
+  createMetricsCollector,
+  createMetricsInterceptors,
+  createMiddlewares,
+  createNoAuthenticator,
+  createReportingInterceptor,
+  createRequestDeduper,
+  createRequestIdInterceptor,
+  createRetryInterceptor,
+  createSilentLogger,
+  createTimeoutInterceptor,
+  createTokenRefreshInterceptor,
+  createTraceInterceptor,
+  createTrackingMiddleware,
+  extractPath,
+  extractResponseHeaders,
   generateRequestId,
-  sleep
+  generateTraceId,
+  getErrorType,
+  getHeader,
+  getRecommendedRetryDelay,
+  getRetryDelay,
+  getSdkInfo,
+  hasContentType,
+  isClientError,
+  isRetryableError,
+  isValidRequestId,
+  isValidTraceId,
+  joinPaths,
+  mergeHeaders,
+  noAuthenticator,
+  parseQueryString,
+  parseRetryAfter,
+  removeHeader,
+  setHeader,
+  silentLogger,
+  sleep,
+  sleepWithAbort
 };
 /*! Bundled license information:
 
@@ -15724,4 +18073,3 @@ mime-types/index.js:
    * MIT Licensed
    *)
 */
-//# sourceMappingURL=index.mjs.map