lexmount 0.2.0

package/dist/index.mjs

@@ -0,0 +1,846 @@
+// src/client.ts
+import {
+  isAxiosError
+} from "axios";
+import axios from "axios";
+import * as dotenv from "dotenv";
+
+// src/errors.ts
+var LexmountError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var AuthenticationError = class extends LexmountError {
+};
+var SessionNotFoundError = class extends LexmountError {
+};
+var ContextNotFoundError = class extends LexmountError {
+};
+var ContextLockedError = class extends LexmountError {
+  constructor(message, options = {}) {
+    const details = [];
+    if (options.activeSessionId) {
+      details.push(`locked by session: ${options.activeSessionId}`);
+    }
+    if (typeof options.retryAfter === "number") {
+      details.push(`retry after ${options.retryAfter}s`);
+    }
+    super(details.length > 0 ? `${message} (${details.join(", ")})` : message);
+    this.activeSessionId = options.activeSessionId;
+    this.retryAfter = options.retryAfter;
+  }
+};
+var APIError = class extends LexmountError {
+  constructor(message, options = {}) {
+    super(
+      typeof options.statusCode === "number" ? `${message} (HTTP ${options.statusCode})` : message
+    );
+    this.statusCode = options.statusCode;
+    this.response = options.response;
+  }
+};
+var NetworkError = class extends LexmountError {
+};
+var ValidationError = class extends LexmountError {
+};
+var TimeoutError = class extends LexmountError {
+};
+
+// src/logging.ts
+var LOGGER_NAME = "lexmount";
+var LOG_LEVEL_PRIORITY = {
+  DEBUG: 10,
+  INFO: 20,
+  WARNING: 30,
+  ERROR: 40,
+  CRITICAL: 50,
+  SILENT: 60
+};
+var currentLevel = "WARNING";
+function isLogLevel(value) {
+  return value in LOG_LEVEL_PRIORITY;
+}
+function formatTimestamp(date) {
+  return date.toISOString().replace("T", " ").replace("Z", "");
+}
+function shouldLog(level) {
+  return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[currentLevel];
+}
+function emit(level, args) {
+  if (!shouldLog(level)) {
+    return;
+  }
+  const prefix = `${formatTimestamp(/* @__PURE__ */ new Date())} - ${LOGGER_NAME} - ${level} -`;
+  if (level === "ERROR" || level === "CRITICAL") {
+    console.error(prefix, ...args);
+    return;
+  }
+  if (level === "WARNING") {
+    console.warn(prefix, ...args);
+    return;
+  }
+  if (level === "INFO") {
+    console.info(prefix, ...args);
+    return;
+  }
+  console.debug(prefix, ...args);
+}
+var LexmountLogger = class {
+  /**
+   * Current SDK log level.
+   */
+  get level() {
+    return currentLevel;
+  }
+  debug(...args) {
+    emit("DEBUG", args);
+  }
+  info(...args) {
+    emit("INFO", args);
+  }
+  warn(...args) {
+    emit("WARNING", args);
+  }
+  error(...args) {
+    emit("ERROR", args);
+  }
+  critical(...args) {
+    emit("CRITICAL", args);
+  }
+};
+var logger = new LexmountLogger();
+function getLogger() {
+  return logger;
+}
+function setLogLevel(level) {
+  if (typeof level !== "string" || level.trim() === "") {
+    throw new ValidationError(
+      "Invalid log level. Valid levels are: DEBUG, INFO, WARNING, ERROR, CRITICAL, SILENT"
+    );
+  }
+  const normalizedLevel = level.toUpperCase();
+  if (!isLogLevel(normalizedLevel)) {
+    throw new ValidationError(
+      `Invalid log level: ${level}. Valid levels are: DEBUG, INFO, WARNING, ERROR, CRITICAL, SILENT`
+    );
+  }
+  currentLevel = normalizedLevel;
+  logger.debug(`Log level set to ${normalizedLevel}`);
+}
+function disableLogging() {
+  currentLevel = "SILENT";
+}
+function enableLogging(level = "INFO") {
+  setLogLevel(level);
+}
+
+// src/contexts.ts
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function getString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function parseTimestamp(value) {
+  if (typeof value === "string" && value.length > 0) {
+    return value;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  return null;
+}
+function normalizeContextStatus(value) {
+  if (value === true || value === "locked") {
+    return "locked";
+  }
+  if (value === false || value === "available") {
+    return "available";
+  }
+  return typeof value === "string" ? value : "available";
+}
+var ContextInfo = class {
+  constructor(options) {
+    this.id = options.id;
+    this.status = options.status;
+    this.metadata = options.metadata ?? {};
+    this.createdAt = options.createdAt ?? null;
+    this.updatedAt = options.updatedAt ?? null;
+  }
+  get createdAtDate() {
+    if (!this.createdAt) {
+      return null;
+    }
+    const date = new Date(this.createdAt);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  get updatedAtDate() {
+    if (!this.updatedAt) {
+      return null;
+    }
+    const date = new Date(this.updatedAt);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  isLocked() {
+    return this.status === "locked";
+  }
+  isAvailable() {
+    return this.status === "available";
+  }
+};
+var ContextListResponse = class {
+  constructor(data) {
+    this.data = data;
+  }
+  get length() {
+    return this.data.length;
+  }
+  [Symbol.iterator]() {
+    return this.data[Symbol.iterator]();
+  }
+  at(index) {
+    return this.data[index];
+  }
+};
+var ContextsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new persistent context.
+   */
+  async create(options = {}) {
+    const url = `${this.client.baseUrl}/instance/v1/contexts/create-context`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: this.client.projectId
+    };
+    if (options.metadata) {
+      payload.metadata = options.metadata;
+    }
+    const response = await this.client._post(url, payload);
+    if (response.status >= 400) {
+      this.handleError(response, "create");
+    }
+    const result = asRecord(response.data);
+    const contextId = getString(result.context_id);
+    if (!contextId) {
+      throw new APIError("Failed to create context: context_id missing from response", {
+        statusCode: response.status,
+        response: response.data
+      });
+    }
+    const context = new ContextInfo({
+      id: contextId,
+      status: normalizeContextStatus(result.locked),
+      metadata: result.metadata ?? options.metadata ?? {},
+      createdAt: parseTimestamp(result.created_at)
+    });
+    getLogger().info(`Successfully created context '${context.id}'`);
+    return context;
+  }
+  /**
+   * List contexts in the current project.
+   */
+  async list(options = {}) {
+    const url = `${this.client.baseUrl}/instance/v1/contexts/list-contexts`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: this.client.projectId,
+      limit: options.limit ?? 20
+    };
+    if (options.status) {
+      payload.status = options.status;
+    }
+    const response = await this.client._post(url, payload);
+    if (response.status >= 400) {
+      this.handleError(response, "list");
+    }
+    const result = asRecord(response.data);
+    const contexts = Array.isArray(result.contexts) ? result.contexts.map((item) => {
+      const context = asRecord(item);
+      return new ContextInfo({
+        id: getString(context.context_id) ?? "",
+        status: normalizeContextStatus(context.locked),
+        createdAt: parseTimestamp(context.created_at),
+        updatedAt: parseTimestamp(context.updated_at),
+        metadata: context.metadata ?? {}
+      });
+    }) : [];
+    getLogger().info(`Retrieved ${contexts.length} contexts`);
+    return new ContextListResponse(contexts);
+  }
+  /**
+   * Fetch a single context.
+   */
+  async get(contextId) {
+    const url = `${this.client.baseUrl}/instance/v1/contexts/${contextId}`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: this.client.projectId
+    };
+    const response = await this.client._post(url, payload);
+    if (response.status >= 400) {
+      this.handleError(response, "get", contextId);
+    }
+    const result = asRecord(response.data);
+    const context = asRecord(result.context);
+    const contextInfo = new ContextInfo({
+      id: getString(context.context_id) ?? contextId,
+      status: normalizeContextStatus(context.locked),
+      metadata: context.metadata ?? {},
+      createdAt: parseTimestamp(context.created_at),
+      updatedAt: parseTimestamp(context.updated_at)
+    });
+    getLogger().info(`Retrieved context '${contextInfo.id}' (status: ${contextInfo.status})`);
+    return contextInfo;
+  }
+  /**
+   * Delete a persistent context.
+   */
+  async delete(contextId) {
+    const url = `${this.client.baseUrl}/instance/v1/contexts/${contextId}`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: this.client.projectId
+    };
+    const response = await this.client._delete(url, payload);
+    if (response.status >= 400) {
+      this.handleError(response, "delete", contextId);
+    }
+    getLogger().info(`Successfully deleted context '${contextId}'`);
+  }
+  /**
+   * Force-release a stuck lock on a context.
+   */
+  async forceRelease(contextId) {
+    const url = `${this.client.baseUrl}/instance/v1/contexts/${contextId}/force-release`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: this.client.projectId
+    };
+    const response = await this.client._post(url, payload);
+    if (response.status >= 400) {
+      this.handleError(response, "force_release", contextId);
+    }
+    const result = asRecord(response.data);
+    return {
+      status: getString(result.status) ?? "unlocked",
+      message: getString(result.message) ?? "Lock released successfully"
+    };
+  }
+  handleError(response, operation, contextId) {
+    const errorData = asRecord(response.data);
+    const errorMessage = getString(errorData.error) ?? getString(errorData.message) ?? "Unknown error";
+    const errorCode = getString(errorData.code);
+    const metadata = asRecord(errorData.metadata);
+    if (response.status === 401) {
+      throw new AuthenticationError(`Authentication failed: ${errorMessage}`);
+    }
+    if (response.status === 404) {
+      const suffix = contextId ? `: ${contextId}` : "";
+      throw new ContextNotFoundError(`Context not found${suffix}`);
+    }
+    if (response.status === 409 && errorCode === "context_locked") {
+      throw new ContextLockedError(errorMessage, {
+        activeSessionId: getString(metadata.activeSessionId),
+        retryAfter: typeof metadata.retryAfter === "number" ? metadata.retryAfter : void 0
+      });
+    }
+    if (response.status === 409 && errorCode === "session_active") {
+      throw new APIError(
+        `Cannot ${operation} context: ${errorMessage} (session is active)`,
+        {
+          statusCode: response.status,
+          response: response.data
+        }
+      );
+    }
+    if (response.status === 500) {
+      const details = getString(errorData.details);
+      throw new APIError(
+        `Internal server error (500) during ${operation}: ${errorMessage}${details ? `. Details: ${details}` : ""}`,
+        {
+          statusCode: response.status,
+          response: response.data
+        }
+      );
+    }
+    if (response.status === 502) {
+      throw new APIError(
+        `Server gateway error (502) during ${operation}: The service may be temporarily unavailable. Please retry.`,
+        {
+          statusCode: response.status,
+          response: response.data
+        }
+      );
+    }
+    if (response.status === 503) {
+      throw new APIError(
+        `Service unavailable (503) during ${operation}: The service is temporarily unavailable. Please retry later.`,
+        {
+          statusCode: response.status,
+          response: response.data
+        }
+      );
+    }
+    if (response.status === 504) {
+      throw new APIError(
+        `Gateway timeout (504) during ${operation}: The request timed out. Please retry.`,
+        {
+          statusCode: response.status,
+          response: response.data
+        }
+      );
+    }
+    throw new APIError(`Failed to ${operation} context: ${errorMessage}`, {
+      statusCode: response.status,
+      response: response.data
+    });
+  }
+};
+
+// src/sessions.ts
+function asRecord2(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function getString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function getNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function normalizeContextMode(mode) {
+  if (mode === "readWrite" || mode === "read_write") {
+    return "read_write";
+  }
+  return "read_only";
+}
+var PaginationInfo = class {
+  constructor(shape) {
+    this.currentPage = shape.currentPage;
+    this.pageSize = shape.pageSize;
+    this.totalCount = shape.totalCount;
+    this.totalPages = shape.totalPages;
+    this.activeCount = shape.activeCount;
+    this.closedCount = shape.closedCount;
+  }
+};
+var SessionInfo = class {
+  /** @internal */
+  constructor(options) {
+    this.closed = false;
+    this.id = options.id;
+    this.sessionId = options.id;
+    this.status = options.status;
+    this.apiKey = options.apiKey;
+    this.projectId = options.projectId;
+    this.browserType = options.browserType;
+    this.createdAt = options.createdAt;
+    this.inspectUrl = options.inspectUrl;
+    this.containerId = options.containerId;
+    this.inspectUrlDbg = options.inspectUrlDbg;
+    this.ws = options.ws ?? null;
+    this.client = options.client;
+  }
+  /**
+   * Playwright/CDP connection URL.
+   */
+  get connectUrl() {
+    return this.ws ?? "";
+  }
+  /**
+   * Parsed session creation time.
+   */
+  get createdAtDate() {
+    const date = new Date(this.createdAt);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  /**
+   * Close the current session.
+   *
+   * This method is idempotent. Errors are logged and swallowed to keep cleanup safe.
+   */
+  async close() {
+    if (this.closed) {
+      getLogger().debug(`Session ${this.sessionId} is already closed.`);
+      return;
+    }
+    if (!this.client) {
+      getLogger().warn(
+        `Cannot close session ${this.sessionId}: client was not provided during session creation.`
+      );
+      return;
+    }
+    try {
+      getLogger().debug(`Closing session ${this.sessionId}`);
+      await this.client.sessions.delete({
+        sessionId: this.sessionId,
+        projectId: this.projectId
+      });
+      this.closed = true;
+      getLogger().info(`Session closed: ${this.sessionId}`);
+    } catch (error) {
+      getLogger().warn(`Failed to close session ${this.sessionId}:`, error);
+    }
+  }
+};
+var SessionListResponse = class {
+  constructor(sessions, pagination) {
+    this.sessions = sessions;
+    this.pagination = pagination;
+  }
+  /**
+   * Number of sessions in the current page.
+   */
+  get length() {
+    return this.sessions.length;
+  }
+  [Symbol.iterator]() {
+    return this.sessions[Symbol.iterator]();
+  }
+  at(index) {
+    return this.sessions[index];
+  }
+};
+var SessionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new browser session.
+   */
+  async create(options = {}) {
+    const url = `${this.client.baseUrl}/instance`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: options.projectId ?? this.client.projectId,
+      browser_mode: options.browserMode ?? "normal"
+    };
+    if (options.context) {
+      const contextPayload = {
+        id: options.context.id,
+        mode: normalizeContextMode(options.context.mode)
+      };
+      payload.context = contextPayload;
+      getLogger().debug(
+        `Creating session with context (id=${options.context.id}, mode=${contextPayload.mode})`
+      );
+    } else {
+      getLogger().debug(`Creating session with browser_mode=${payload.browser_mode}`);
+    }
+    const response = await this.client._post(url, payload);
+    if (response.status >= 400) {
+      this.handleCreateError(response);
+    }
+    const result = asRecord2(response.data);
+    const sessionId = getString2(result.session_id);
+    if (!sessionId) {
+      throw new APIError("Failed to create session: session_id missing from response", {
+        statusCode: response.status,
+        response: response.data
+      });
+    }
+    const containerId = getString2(result.container_id) ?? null;
+    const wsUrl = await this._getWebSocketDebuggerUrl(sessionId);
+    const projectId = options.projectId ?? this.client.projectId;
+    getLogger().info(`Session created successfully: id=${sessionId}, container_id=${containerId}`);
+    return new SessionInfo({
+      id: sessionId,
+      status: "active",
+      apiKey: this.client.apiKey,
+      projectId,
+      browserType: options.browserMode ?? "normal",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      inspectUrl: `${this.client.baseUrl}/inspect?session_id=${sessionId}`,
+      containerId,
+      ws: wsUrl,
+      client: this.client
+    });
+  }
+  /**
+   * List sessions for the current project.
+   */
+  async list(options = {}) {
+    const url = `${this.client.baseUrl}/instance/v2/sessions`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: options.projectId ?? this.client.projectId
+    };
+    if (options.status) {
+      payload.status = options.status;
+    }
+    const response = await this.client._post(url, payload);
+    if (response.status >= 400) {
+      this.handleListError(response);
+    }
+    const result = asRecord2(response.data);
+    const sessionsData = Array.isArray(result.sessions) ? result.sessions : [];
+    const paginationData = asRecord2(result.pagination);
+    const sessions = sessionsData.map((item) => {
+      const session = asRecord2(item);
+      const sessionId = getString2(session.id) ?? "";
+      return new SessionInfo({
+        id: sessionId,
+        status: getString2(session.status) ?? "active",
+        apiKey: getString2(session.api_key) ?? this.client.apiKey,
+        projectId: getString2(session.project_id) ?? (options.projectId ?? this.client.projectId),
+        browserType: getString2(session.browser_type) ?? "normal",
+        createdAt: getString2(session.created_at) ?? "",
+        inspectUrl: getString2(session.inspect_url) ?? `${this.client.baseUrl}/inspect?session_id=${sessionId}`,
+        containerId: getString2(session.container_id) ?? null,
+        inspectUrlDbg: getString2(session.inspect_url_dbg),
+        ws: getString2(session.ws) ?? null,
+        client: this.client
+      });
+    });
+    const pagination = new PaginationInfo({
+      currentPage: getNumber(paginationData.currentPage) ?? 1,
+      pageSize: getNumber(paginationData.pageSize) ?? sessions.length,
+      totalCount: getNumber(paginationData.totalCount) ?? sessions.length,
+      totalPages: getNumber(paginationData.totalPages) ?? 1,
+      activeCount: getNumber(paginationData.activeCount) ?? 0,
+      closedCount: getNumber(paginationData.closedCount) ?? 0
+    });
+    getLogger().info(
+      `Retrieved ${sessions.length} sessions (total: ${pagination.totalCount}, active: ${pagination.activeCount}, closed: ${pagination.closedCount})`
+    );
+    return new SessionListResponse(sessions, pagination);
+  }
+  /**
+   * Delete a browser session.
+   */
+  async delete(options) {
+    const url = `${this.client.baseUrl}/instance`;
+    const payload = {
+      api_key: this.client.apiKey,
+      project_id: options.projectId ?? this.client.projectId,
+      session_id: options.sessionId
+    };
+    const response = await this.client._delete(url, payload);
+    if (response.status >= 400) {
+      this.handleDeleteError(response, options.sessionId);
+    }
+    getLogger().info(`Session deleted successfully: ${options.sessionId}`);
+  }
+  /**
+   * Fetch the debugger WebSocket URL for a session.
+   *
+   * @internal
+   */
+  async _getWebSocketDebuggerUrl(sessionId) {
+    try {
+      const response = await this.client._get(`${this.client.baseUrl}/json/version`, {
+        session_id: sessionId
+      });
+      if (response.status >= 400) {
+        getLogger().error("Error getting WebSocket debugger URL:", response.data);
+        return null;
+      }
+      const result = asRecord2(response.data);
+      return getString2(result.webSocketDebuggerUrlTransformed) ?? getString2(result.webSocketDebuggerUrl) ?? null;
+    } catch (error) {
+      getLogger().error("Error getting WebSocket debugger URL:", error);
+      return null;
+    }
+  }
+  handleCreateError(response) {
+    const errorData = asRecord2(response.data);
+    const errorMessage = getString2(errorData.error) ?? getString2(errorData.message) ?? "Unknown error";
+    const errorCode = getString2(errorData.code);
+    const metadata = asRecord2(errorData.metadata);
+    if (response.status === 401) {
+      throw new AuthenticationError(
+        `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
+      );
+    }
+    if (response.status === 404 && errorCode === "context_not_found") {
+      throw new ContextNotFoundError(`Context not found: ${errorMessage}`);
+    }
+    if (response.status === 404) {
+      throw new SessionNotFoundError(`Resource not found: ${errorMessage}`);
+    }
+    if (response.status === 409 && errorCode === "context_locked") {
+      throw new ContextLockedError(errorMessage, {
+        activeSessionId: getString2(metadata.activeSessionId),
+        retryAfter: getNumber(metadata.retryAfter)
+      });
+    }
+    throw new APIError(`Failed to create session: ${errorMessage}`, {
+      statusCode: response.status,
+      response: response.data
+    });
+  }
+  handleListError(response) {
+    const errorData = asRecord2(response.data);
+    const errorMessage = getString2(errorData.error) ?? getString2(errorData.message) ?? "Unknown error";
+    if (response.status === 401) {
+      throw new AuthenticationError(
+        `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
+      );
+    }
+    throw new APIError(`Failed to list sessions: ${errorMessage}`, {
+      statusCode: response.status,
+      response: response.data
+    });
+  }
+  handleDeleteError(response, sessionId) {
+    const errorData = asRecord2(response.data);
+    const errorMessage = getString2(errorData.error) ?? getString2(errorData.message) ?? "Unknown error";
+    if (response.status === 401) {
+      throw new AuthenticationError(
+        `Authentication failed: ${errorMessage}. Please check your API key and project ID.`
+      );
+    }
+    if (response.status === 404) {
+      throw new SessionNotFoundError(
+        `Session not found: ${errorMessage}. Session ID '${sessionId}' may have already been deleted or never existed.`
+      );
+    }
+    throw new APIError(`Failed to delete session: ${errorMessage}`, {
+      statusCode: response.status,
+      response: response.data
+    });
+  }
+};
+
+// src/client.ts
+dotenv.config();
+var Lexmount = class {
+  constructor(config2 = {}) {
+    this.apiKey = config2.apiKey ?? process.env.LEXMOUNT_API_KEY ?? "";
+    if (!this.apiKey) {
+      throw new ValidationError(
+        "apiKey must be provided or set LEXMOUNT_API_KEY environment variable"
+      );
+    }
+    this.projectId = config2.projectId ?? process.env.LEXMOUNT_PROJECT_ID ?? "";
+    if (!this.projectId) {
+      throw new ValidationError(
+        "projectId must be provided or set LEXMOUNT_PROJECT_ID environment variable"
+      );
+    }
+    this.baseUrl = (config2.baseUrl ?? process.env.LEXMOUNT_BASE_URL ?? "https://api.lexmount.cn").replace(/\/$/, "");
+    if (config2.logLevel) {
+      setLogLevel(config2.logLevel);
+    }
+    this.httpClient = axios.create({
+      timeout: config2.timeout ?? 6e4,
+      validateStatus: () => true,
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    this.sessions = new SessionsResource(this);
+    this.contexts = new ContextsResource(this);
+  }
+  /**
+   * Internal POST request helper with timeout and network error mapping.
+   *
+   * @internal
+   */
+  async _post(url, data) {
+    return this.request("POST", url, { data });
+  }
+  /**
+   * Internal GET request helper with timeout and network error mapping.
+   *
+   * @internal
+   */
+  async _get(url, params) {
+    return this.request("GET", url, { params });
+  }
+  /**
+   * Internal DELETE request helper with timeout and network error mapping.
+   *
+   * @internal
+   */
+  async _delete(url, data) {
+    return this.request("DELETE", url, { data });
+  }
+  /**
+   * Close the client.
+   *
+   * Axios does not require explicit teardown, but the method is kept for API symmetry.
+   */
+  close() {
+    getLogger().debug("Closing Lexmount client");
+  }
+  /**
+   * String representation of the client.
+   */
+  toString() {
+    return `Lexmount(projectId='${this.projectId}', baseUrl='${this.baseUrl}')`;
+  }
+  async request(method, url, config2) {
+    const logger2 = getLogger();
+    const startTime = Date.now();
+    logger2.debug(`${method} request to ${url}`);
+    try {
+      const response = await this.httpClient.request({
+        method,
+        url,
+        ...config2
+      });
+      const elapsed = Date.now() - startTime;
+      logger2.debug(`${method} response: status=${response.status}, duration=${elapsed.toFixed(2)}ms`);
+      return response;
+    } catch (error) {
+      const elapsed = Date.now() - startTime;
+      throw this.normalizeRequestError(error, elapsed);
+    }
+  }
+  normalizeRequestError(error, elapsedMs) {
+    const logger2 = getLogger();
+    if (!isAxiosError(error)) {
+      logger2.error(`Unexpected request error after ${elapsedMs.toFixed(2)}ms:`, error);
+      return new APIError("Unexpected HTTP error", { response: error });
+    }
+    const axiosError = error;
+    if (axiosError.code === "ECONNABORTED") {
+      logger2.error(`Request timeout after ${elapsedMs.toFixed(2)}ms:`, axiosError.message);
+      return new TimeoutError(`Request timed out: ${axiosError.message}`);
+    }
+    if (axiosError.response) {
+      logger2.error(`HTTP error after ${elapsedMs.toFixed(2)}ms:`, axiosError.message);
+      return new APIError(`HTTP error: ${axiosError.message}`, {
+        statusCode: axiosError.response.status,
+        response: axiosError.response.data
+      });
+    }
+    logger2.error(`Network error after ${elapsedMs.toFixed(2)}ms:`, axiosError.message);
+    return new NetworkError(`Network error: ${axiosError.message}`);
+  }
+};
+
+// src/index.ts
+var VERSION = "0.2.0";
+export {
+  APIError,
+  AuthenticationError,
+  ContextInfo,
+  ContextListResponse,
+  ContextLockedError,
+  ContextNotFoundError,
+  ContextsResource,
+  Lexmount,
+  LexmountError,
+  LexmountLogger,
+  NetworkError,
+  PaginationInfo,
+  SessionInfo,
+  SessionListResponse,
+  SessionNotFoundError,
+  SessionsResource,
+  TimeoutError,
+  VERSION,
+  ValidationError,
+  Lexmount as default,
+  disableLogging,
+  enableLogging,
+  getLogger,
+  setLogLevel
+};
+//# sourceMappingURL=index.mjs.map