lumnisai 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const DEFAULT_BASE_URL = "https://api.lumnis.ai";
+const DEFAULT_POLL_INTERVAL_MS = 2e3;
+const LONG_POLL_TIMEOUT_S = 10;
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_BACKOFF_FACTOR = 0.5;
+
+class ExternalAPIKeysResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Store a new external API key (encrypted)
+   */
+  async store(data) {
+    return this.http.post("/external-api-keys", data);
+  }
+  /**
+   * Create a new external API key (alias for store)
+   */
+  async create(data) {
+    return this.store(data);
+  }
+  /**
+   * List all configured external API keys (metadata only, no key values)
+   */
+  async list() {
+    return this.http.get("/external-api-keys");
+  }
+  /**
+   * Get details for a specific external API key (no key value)
+   */
+  async get(keyId) {
+    return this.http.get(`/external-api-keys/${keyId}`);
+  }
+  /**
+   * Delete an external API key for a specific provider
+   */
+  async delete(provider) {
+    return this.http.delete(`/external-api-keys/${provider}`);
+  }
+  /**
+   * Get the current API key mode
+   */
+  async getMode() {
+    return this.http.get("/external-api-keys/mode");
+  }
+  /**
+   * Update the API key mode
+   */
+  async updateMode(data) {
+    return this.http.patch("/external-api-keys/mode", data);
+  }
+  /**
+   * Set the API key mode (alias for updateMode)
+   */
+  async setMode(data) {
+    return this.updateMode(data);
+  }
+}
+
+class FilesResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Upload a new file for processing
+   * @param file - The file to upload (File or Blob)
+   * @param options - Upload options
+   * @param options.scope - File access scope (user or tenant)
+   * @param options.userId - User ID or email (required for user-scoped files)
+   * @param options.tags - Comma-separated tags for categorization
+   * @param options.duplicateHandling - How to handle duplicate filenames
+   */
+  async upload(file, options) {
+    const formData = new FormData();
+    formData.append("file", file);
+    formData.append("scope", options.scope);
+    if (options.userId)
+      formData.append("user_id", options.userId);
+    if (options.tags)
+      formData.append("tags", options.tags);
+    if (options.duplicateHandling)
+      formData.append("duplicate_handling", options.duplicateHandling);
+    return this.http.post("/files/upload", formData);
+  }
+  /**
+   * Upload multiple files at once
+   */
+  async bulkUpload(files, options) {
+    const formData = new FormData();
+    for (const file of files)
+      formData.append("files", file);
+    formData.append("scope", options.scope);
+    if (options.userId)
+      formData.append("user_id", options.userId);
+    if (options.tags)
+      formData.append("tags", options.tags);
+    return this.http.post("/files/bulk-upload", formData);
+  }
+  /**
+   * Get file metadata by ID
+   */
+  async get(fileId, userId) {
+    const params = userId ? { user_id: userId } : void 0;
+    return this.http.get(`/files/${fileId}`, { params });
+  }
+  /**
+   * List files with optional filters
+   */
+  async list(params) {
+    return this.http.get("/files", { params });
+  }
+  /**
+   * Get file content
+   */
+  async getContent(fileId, options) {
+    const params = {
+      content_type: options?.contentType,
+      start_line: options?.startLine,
+      end_line: options?.endLine,
+      user_id: options?.userId
+    };
+    return this.http.get(`/files/${fileId}/content`, { params });
+  }
+  /**
+   * Download original file
+   * Returns a redirect URL for blob storage or file content directly
+   */
+  async download(fileId, userId) {
+    const params = userId ? { user_id: userId } : void 0;
+    return this.http.request(`/files/${fileId}/download`, {
+      method: "GET",
+      params
+    });
+  }
+  /**
+   * Update file access scope
+   */
+  async updateScope(fileId, data) {
+    return this.http.patch(`/files/${fileId}/scope`, data);
+  }
+  /**
+   * Delete a file
+   */
+  async delete(fileId, options) {
+    const params = {
+      hard_delete: options?.hardDelete ?? true,
+      user_id: options?.userId
+    };
+    return this.http.delete(`/files/${fileId}`, { params });
+  }
+  /**
+   * Delete multiple files at once
+   */
+  async bulkDelete(data, options) {
+    const params = {
+      hard_delete: options?.hardDelete ?? true,
+      user_id: options?.userId
+    };
+    return this.http.request("/files/bulk", {
+      method: "DELETE",
+      body: data,
+      params
+    });
+  }
+  /**
+   * Get file processing status
+   */
+  async getStatus(fileId, userId) {
+    const params = userId ? { user_id: userId } : void 0;
+    return this.http.get(`/files/${fileId}/status`, { params });
+  }
+  /**
+   * Semantic search across files
+   */
+  async search(request) {
+    return this.http.post("/files/search", request);
+  }
+  /**
+   * Get file statistics for the tenant
+   */
+  async getStatistics() {
+    return this.http.get("/files/statistics");
+  }
+}
+
+class IntegrationsResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Start an OAuth connection flow for a user
+   */
+  async initiateConnection(data) {
+    const requestData = {
+      ...data,
+      appName: data.appName.toUpperCase()
+    };
+    return this.http.post("/integrations/connections/initiate", requestData);
+  }
+  /**
+   * Check the status of a specific connection
+   */
+  async getConnectionStatus(userId, appName) {
+    return this.http.get(
+      `/integrations/connections/${encodeURIComponent(userId)}/${appName.toUpperCase()}`
+    );
+  }
+  /**
+   * Get all connections for a user
+   */
+  async getUserConnections(userId, appFilter) {
+    const params = new URLSearchParams();
+    if (appFilter)
+      params.append("app_filter", appFilter);
+    const query = params.toString() ? `?${params.toString()}` : "";
+    return this.http.get(
+      `/integrations/connections/${encodeURIComponent(userId)}${query}`
+    );
+  }
+  /**
+   * Get available tools for a user based on connections
+   */
+  async getTools(data) {
+    const requestData = {
+      ...data,
+      appFilter: data.appFilter?.map((app) => app.toUpperCase())
+    };
+    return this.http.post("/integrations/tools", requestData);
+  }
+  /**
+   * Disconnect a user from an external app
+   */
+  async disconnect(data) {
+    const requestData = {
+      ...data,
+      appName: data.appName.toUpperCase()
+    };
+    return this.http.post("/integrations/connections/disconnect", requestData);
+  }
+  /**
+   * Handle OAuth callback (for custom implementations)
+   */
+  async handleCallback(data) {
+    return this.http.post("/integrations/connections/callback", data);
+  }
+  /**
+   * List apps enabled for the tenant
+   */
+  async listApps(params) {
+    const urlParams = new URLSearchParams();
+    if (params?.includeAvailable)
+      urlParams.append("include_available", "true");
+    const query = urlParams.toString() ? `?${urlParams.toString()}` : "";
+    return this.http.get(`/integrations/apps${query}`);
+  }
+  /**
+   * Check if a specific app is enabled
+   */
+  async checkAppEnabled(appName) {
+    return this.http.get(
+      `/integrations/apps/${appName.toUpperCase()}/enabled`
+    );
+  }
+  /**
+   * Enable or disable an app for the tenant
+   */
+  async updateAppStatus(appName, enabled) {
+    return this.http.put(
+      `/integrations/apps/${appName.toUpperCase()}?enabled=${enabled}`
+    );
+  }
+  /**
+   * Get required fields for non-OAuth authentication (future)
+   */
+  async getNonOAuthRequiredFields(appName, authScheme) {
+    const params = new URLSearchParams({ auth_scheme: authScheme });
+    return this.http.get(
+      `/integrations/non-oauth/required-fields/${appName.toUpperCase()}?${params.toString()}`
+    );
+  }
+  // Aliases for backward compatibility with client methods
+  async isAppEnabled(appName) {
+    return this.checkAppEnabled(appName);
+  }
+  async setAppEnabled(appName, data) {
+    return this.updateAppStatus(appName, data.enabled);
+  }
+  async listConnections(userId, params) {
+    return this.getUserConnections(userId, params?.appFilter);
+  }
+}
+
+class MCPServersResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new MCP server configuration
+   */
+  async create(data) {
+    return this.http.post("/mcp-servers", data);
+  }
+  /**
+   * List MCP server configurations
+   */
+  async list(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.scope)
+      queryParams.append("scope", params.scope);
+    if (params?.userIdentifier)
+      queryParams.append("user_identifier", params.userIdentifier);
+    if (params?.isActive !== void 0)
+      queryParams.append("is_active", params.isActive.toString());
+    if (params?.skip)
+      queryParams.append("skip", params.skip.toString());
+    if (params?.limit)
+      queryParams.append("limit", params.limit.toString());
+    const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
+    return this.http.get(`/mcp-servers${query}`);
+  }
+  /**
+   * Get a specific MCP server configuration
+   */
+  async get(serverId) {
+    return this.http.get(`/mcp-servers/${serverId}`);
+  }
+  /**
+   * Update an MCP server configuration
+   */
+  async update(serverId, data) {
+    return this.http.patch(`/mcp-servers/${serverId}`, data);
+  }
+  /**
+   * Delete an MCP server configuration
+   */
+  async delete(serverId) {
+    await this.http.delete(`/mcp-servers/${serverId}`);
+  }
+  /**
+   * List tools provided by an MCP server
+   * Note: Currently returns empty list, tool indexing coming in Phase 1
+   */
+  async listTools(serverId) {
+    return this.http.get(`/mcp-servers/${serverId}/tools`);
+  }
+  /**
+   * Test connection to an MCP server
+   * Note: Currently returns placeholder, testing coming in Phase 1
+   */
+  async testConnection(serverId) {
+    return this.http.post(`/mcp-servers/${serverId}/test`);
+  }
+  /**
+   * Test an MCP server configuration before saving
+   * Validates that the server can be connected to without creating a permanent configuration
+   */
+  async testConfig(config) {
+    return this.http.post("/mcp-servers/test", config);
+  }
+}
+
+class ModelPreferencesResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get all model preferences for the tenant
+   */
+  async get(includeDefaults = true) {
+    const params = new URLSearchParams();
+    params.append("include_defaults", includeDefaults.toString());
+    return this.http.get(`/model-preferences?${params.toString()}`);
+  }
+  /**
+   * Update multiple model preferences in a single request
+   */
+  async updateBulk(data) {
+    return this.http.put("/model-preferences", data);
+  }
+  /**
+   * Update a specific model type preference
+   */
+  async update(modelType, data) {
+    return this.http.patch(`/model-preferences/${modelType}`, data);
+  }
+  /**
+   * Delete a model preference to revert to system default
+   */
+  async delete(modelType) {
+    await this.http.delete(`/model-preferences/${modelType}`);
+  }
+  /**
+   * Check which models are available based on API key configuration
+   */
+  async checkAvailability(models) {
+    return this.http.post("/model-preferences/check-availability", models);
+  }
+  /**
+   * List all model preferences (alias for get)
+   */
+  async list(params) {
+    return this.get(params?.includeDefaults);
+  }
+}
+
+class LumnisError extends Error {
+  code;
+  statusCode;
+  details;
+  requestId;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "LumnisError";
+    this.code = options.code || "UNKNOWN_ERROR";
+    this.statusCode = options.statusCode;
+    this.details = options.details;
+    this.requestId = options.requestId;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+class AuthenticationError extends LumnisError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: options.statusCode || 401 });
+    this.name = "AuthenticationError";
+  }
+}
+class ValidationError extends LumnisError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: options.statusCode || 400 });
+    this.name = "ValidationError";
+  }
+}
+class NotFoundError extends LumnisError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 404 });
+    this.name = "NotFoundError";
+  }
+}
+class RateLimitError extends LumnisError {
+  retryAfter;
+  constructor(options = {}) {
+    super("Rate limit exceeded", { ...options, statusCode: 429 });
+    this.name = "RateLimitError";
+    this.retryAfter = options.retryAfter;
+  }
+}
+class InternalServerError extends LumnisError {
+  constructor(message, options = {}) {
+    super(message, { ...options, statusCode: 500 });
+    this.name = "InternalServerError";
+  }
+}
+class LocalFileNotSupportedError extends ValidationError {
+  constructor(filePath) {
+    super(
+      `Local file paths are not supported yet: ${filePath}. Please wait for the artifact upload API or use artifact IDs.`,
+      { code: "LOCAL_FILE_NOT_SUPPORTED" }
+    );
+    this.name = "LocalFileNotSupportedError";
+  }
+}
+
+class ResponsesResource {
+  constructor(http) {
+    this.http = http;
+  }
+  _validateFileReference(uri) {
+    if (uri.startsWith("artifact_"))
+      return;
+    try {
+      const parsed = new URL(uri);
+      const allowedSchemes = [
+        "http",
+        "https",
+        "s3",
+        "gs",
+        "gcs",
+        "file",
+        "ftp",
+        "ftps",
+        "blob",
+        "data"
+      ];
+      if (allowedSchemes.includes(parsed.protocol.replace(":", ""))) {
+        if ((parsed.protocol === "http:" || parsed.protocol === "https \u043F\u0440\u043E\u0442\u043E\u043A\u043E\u043B:") && !parsed.hostname)
+          throw new LocalFileNotSupportedError(uri);
+        return;
+      } else {
+        throw new LocalFileNotSupportedError(uri);
+      }
+    } catch (error) {
+      if (error instanceof LocalFileNotSupportedError)
+        throw error;
+    }
+    const isLocalPath = uri.startsWith("/") || uri.startsWith("./") || uri.startsWith("../") || /^[a-z]:/i.test(uri) || uri.startsWith("\\\\") || uri.split("/").length === 1 && uri.includes(".") && !uri.startsWith("artifact_");
+    if (isLocalPath)
+      throw new LocalFileNotSupportedError(uri);
+  }
+  /**
+   * Create a new response request for asynchronous processing
+   */
+  async create(request) {
+    if (request.files) {
+      for (const file of request.files)
+        this._validateFileReference(file.uri);
+    }
+    return this.http.post("/responses", request);
+  }
+  /**
+   * Get response status and content
+   * @param responseId - The response ID
+   * @param options - Optional parameters
+   * @param options.wait - Wait time in seconds for long-polling
+   */
+  async get(responseId, options) {
+    return this.http.get(`/responses/${responseId}`, { params: options });
+  }
+  /**
+   * List responses with optional filtering
+   * @param params - Optional filter parameters
+   * @param params.userId - Filter by user ID
+   * @param params.status - Filter by response status
+   * @param params.startDate - Filter responses created after this date
+   * @param params.endDate - Filter responses created before this date
+   * @param params.limit - Maximum number of responses to return
+   * @param params.offset - Number of responses to skip for pagination
+   */
+  async list(params) {
+    const queryParams = {};
+    if (params?.userId)
+      queryParams.user_id = params.userId;
+    if (params?.status)
+      queryParams.status = params.status;
+    if (params?.startDate)
+      queryParams.start_date = params.startDate;
+    if (params?.endDate)
+      queryParams.end_date = params.endDate;
+    if (params?.limit)
+      queryParams.limit = params.limit;
+    if (params?.offset)
+      queryParams.offset = params.offset;
+    return this.http.get("/responses", { params: queryParams });
+  }
+  /**
+   * Cancel a queued or in-progress response
+   */
+  async cancel(responseId) {
+    return this.http.post(`/responses/${responseId}/cancel`);
+  }
+  /**
+   * List artifacts generated by a response
+   */
+  async listArtifacts(responseId, params) {
+    return this.http.get(`/responses/${responseId}/artifacts`, { params });
+  }
+}
+
+class TenantInfoResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Get detailed information about a tenant
+   * Users can only access information about their own tenant
+   */
+  async get(tenantId) {
+    return this.http.get(`/tenants/${tenantId}`);
+  }
+}
+
+class ThreadsResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new thread
+   */
+  async create(params) {
+    return this.http.post("/threads", params);
+  }
+  /**
+   * List threads for the authenticated tenant
+   */
+  async list(params) {
+    return this.http.get("/threads", { params });
+  }
+  /**
+   * Get detailed information about a specific thread
+   */
+  async get(threadId) {
+    return this.http.get(`/threads/${encodeURIComponent(threadId)}`);
+  }
+  /**
+   * Get all responses associated with a specific thread
+   */
+  async getResponses(threadId, params) {
+    return this.http.get(`/threads/${encodeURIComponent(threadId)}/responses`, { params });
+  }
+  /**
+   * Update thread metadata
+   */
+  async update(threadId, data) {
+    return this.http.patch(`/threads/${encodeURIComponent(threadId)}`, data);
+  }
+  /**
+   * Delete a thread and all its associated responses
+   */
+  async delete(threadId) {
+    await this.http.delete(`/threads/${encodeURIComponent(threadId)}`);
+  }
+}
+
+class UsersResource {
+  constructor(http) {
+    this.http = http;
+  }
+  /**
+   * Create a new user within the tenant
+   * Returns existing user with 200 OK if user with same email already exists
+   */
+  async create(data) {
+    return this.http.post("/users", data);
+  }
+  /**
+   * List all users in the tenant with pagination
+   */
+  async list(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page)
+      queryParams.append("page", params.page.toString());
+    if (params?.pageSize)
+      queryParams.append("page_size", params.pageSize.toString());
+    const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
+    return this.http.get(`/users${query}`);
+  }
+  /**
+   * Get user details by ID or email
+   */
+  async get(userIdentifier) {
+    return this.http.get(`/users/${encodeURIComponent(userIdentifier)}`);
+  }
+  /**
+   * Update user information by ID or email
+   */
+  async update(userIdentifier, data) {
+    return this.http.put(`/users/${encodeURIComponent(userIdentifier)}`, data);
+  }
+  /**
+   * Delete (deactivate) a user by ID or email
+   */
+  async delete(userIdentifier) {
+    return this.http.delete(`/users/${encodeURIComponent(userIdentifier)}`);
+  }
+  /**
+   * Get all AI responses generated for a specific user
+   */
+  async getResponses(userIdentifier, params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page)
+      queryParams.append("page", params.page.toString());
+    if (params?.pageSize)
+      queryParams.append("page_size", params.pageSize.toString());
+    const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
+    return this.http.get(`/users/${encodeURIComponent(userIdentifier)}/responses${query}`);
+  }
+  /**
+   * Get all conversation threads for a specific user
+   */
+  async getThreads(userIdentifier, params) {
+    const queryParams = new URLSearchParams();
+    if (params?.page)
+      queryParams.append("page", params.page.toString());
+    if (params?.pageSize)
+      queryParams.append("page_size", params.pageSize.toString());
+    const query = queryParams.toString() ? `?${queryParams.toString()}` : "";
+    return this.http.get(`/users/${encodeURIComponent(userIdentifier)}/threads${query}`);
+  }
+}
+
+function toCamel(s) {
+  return s.replace(/([-_][a-z])/gi, ($1) => {
+    return $1.toUpperCase().replace("-", "").replace("_", "");
+  });
+}
+function toSnake(s) {
+  return s.replace(/[A-Z]/g, (letter, index) => {
+    return index === 0 ? letter.toLowerCase() : `_${letter.toLowerCase()}`;
+  });
+}
+function convertCase(obj, converter) {
+  if (Array.isArray(obj)) {
+    return obj.map((v) => convertCase(v, converter));
+  } else if (obj !== null && typeof obj === "object") {
+    return Object.keys(obj).reduce((acc, key) => {
+      acc[converter(key)] = convertCase(obj[key], converter);
+      return acc;
+    }, {});
+  }
+  return obj;
+}
+function toCamelCase(obj) {
+  return convertCase(obj, toCamel);
+}
+function toSnakeCase(obj) {
+  return convertCase(obj, toSnake);
+}
+
+class Http {
+  options;
+  constructor(options) {
+    this.options = {
+      baseUrl: options.baseUrl.replace(/\/$/, ""),
+      apiPrefix: options.apiPrefix || "",
+      headers: options.headers || {},
+      timeoutMs: options.timeoutMs || DEFAULT_TIMEOUT_MS,
+      maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+      backoffFactor: options.backoffFactor || DEFAULT_BACKOFF_FACTOR
+    };
+  }
+  async _handleResponse(response) {
+    const requestId = response.headers.get("x-request-id");
+    if (response.ok) {
+      if (response.status === 204)
+        return null;
+      const contentType = response.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        const json = await response.json();
+        return toCamelCase(json);
+      }
+      return await response.text();
+    }
+    let detail = { raw: await response.text() };
+    try {
+      if (response.headers.get("content-type")?.includes("application/json"))
+        detail = JSON.parse(detail.raw);
+    } catch {
+    }
+    const errorMsg = detail?.error?.message || `Server error: ${response.status}`;
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError("Invalid or missing API key", { requestId, statusCode: 401, details: detail });
+      case 403:
+        throw new AuthenticationError("Forbidden - insufficient permissions", { requestId, statusCode: 403, details: detail });
+      case 404:
+        throw new NotFoundError("Resource not found", { requestId, statusCode: 404, details: detail });
+      case 429: {
+        const retryAfter = response.headers.get("Retry-After");
+        throw new RateLimitError({ requestId, statusCode: 429, details: detail, retryAfter });
+      }
+      default:
+        if (response.status >= 400 && response.status < 500)
+          throw new ValidationError(errorMsg, { requestId, statusCode: response.status, details: detail });
+        throw new LumnisError(`Server error: ${response.status}`, { requestId, statusCode: response.status, details: detail });
+    }
+  }
+  async request(path, init = {}) {
+    const { body, params, idempotencyKey: idempotencyKeyOption, ...fetchOptions } = init;
+    const method = fetchOptions.method || "GET";
+    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    const fullPath = this.options.apiPrefix ? `${this.options.apiPrefix}${normalizedPath}` : normalizedPath;
+    const url = new URL(this.options.baseUrl + fullPath);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null)
+          url.searchParams.append(key, String(value));
+      }
+    }
+    const idempotencyKey = idempotencyKeyOption || (method !== "GET" ? crypto.randomUUID() : void 0);
+    const headers = {
+      "content-type": "application/json",
+      ...this.options.headers,
+      ...fetchOptions.headers,
+      ...idempotencyKey ? { "Idempotency-Key": idempotencyKey } : {}
+    };
+    const isIdempotent = method === "GET" || method === "DELETE" || !!idempotencyKey;
+    const maxAttempts = isIdempotent ? this.options.maxRetries + 1 : 1;
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs);
+      try {
+        const response = await fetch(url.toString(), {
+          ...fetchOptions,
+          method,
+          headers,
+          body: body ? JSON.stringify(toSnakeCase(body)) : void 0,
+          signal: controller.signal
+        });
+        return await this._handleResponse(response);
+      } catch (error) {
+        lastError = error;
+        if (error instanceof RateLimitError) {
+          const backoff = backoffMs(attempt, error.retryAfter);
+          await sleep(backoff);
+          continue;
+        }
+        if (error instanceof LumnisError && (error.statusCode ?? 0) < 500)
+          throw error;
+        if (attempt < maxAttempts - 1) {
+          const backoff = backoffMs(attempt);
+          await sleep(backoff);
+        }
+      } finally {
+        clearTimeout(timeout);
+      }
+    }
+    throw lastError || new LumnisError("Request failed after all retries", {});
+  }
+  get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  post(path, body, options) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  put(path, body, options) {
+    return this.request(path, { ...options, method: "PUT", body });
+  }
+  patch(path, body, options) {
+    return this.request(path, { ...options, method: "PATCH", body });
+  }
+  delete(path, options) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+  async warnTenantScope() {
+    console.warn(
+      "Using TENANT scope bypasses user isolation. Ensure this is intentional and follows security best practices."
+    );
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function backoffMs(attempt, retryAfter = null) {
+  if (retryAfter) {
+    const retryAfterMs = Number(retryAfter) * 1e3;
+    if (!Number.isNaN(retryAfterMs))
+      return retryAfterMs;
+  }
+  const jitter = Math.random() * 500;
+  return Math.min(1e3 * 2 ** attempt, 1e4) + jitter;
+}
+
+class LumnisClient {
+  http;
+  tenantId;
+  // Resources
+  threads;
+  responses;
+  users;
+  files;
+  tenantInfo;
+  externalApiKeys;
+  integrations;
+  modelPreferences;
+  mcpServers;
+  _scopedUserId;
+  _defaultScope;
+  constructor(options = {}) {
+    const apiKey = options.apiKey || typeof process !== "undefined" && process.env?.LUMNISAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("API key is required. Provide it via options.apiKey or set LUMNISAI_API_KEY environment variable.");
+    }
+    this.tenantId = options.tenantId || typeof process !== "undefined" && process.env?.LUMNISAI_TENANT_ID || void 0;
+    const baseUrl = options.baseUrl || typeof process !== "undefined" && process.env?.LUMNISAI_BASE_URL || DEFAULT_BASE_URL;
+    this._defaultScope = options.scope || "tenant";
+    this._scopedUserId = options._scopedUserId;
+    this.http = new Http({
+      baseUrl,
+      apiPrefix: "/v1",
+      headers: {
+        "X-API-Key": apiKey
+      },
+      timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES
+    });
+    this.threads = new ThreadsResource(this.http);
+    this.responses = new ResponsesResource(this.http);
+    this.users = new UsersResource(this.http);
+    this.files = new FilesResource(this.http);
+    this.tenantInfo = new TenantInfoResource(this.http);
+    this.externalApiKeys = new ExternalAPIKeysResource(this.http);
+    this.integrations = new IntegrationsResource(this.http);
+    this.modelPreferences = new ModelPreferencesResource(this.http);
+    this.mcpServers = new MCPServersResource(this.http);
+  }
+  forUser(userId) {
+    return new LumnisClient({
+      apiKey: this.http.options.headers["X-API-Key"],
+      tenantId: this.tenantId,
+      baseUrl: this.http.options.baseUrl,
+      timeoutMs: this.http.options.timeoutMs,
+      maxRetries: this.http.options.maxRetries,
+      scope: "user",
+      _scopedUserId: userId
+    });
+  }
+  async invoke(messages, options) {
+    const { stream = false, showProgress = true, ...restOptions } = options || {};
+    if (stream) {
+      if (showProgress)
+        console.warn("showProgress is not supported in streaming mode.");
+      return this._invokeStream(messages, restOptions);
+    } else {
+      let progressCallback;
+      if (showProgress)
+        progressCallback = createSimpleProgressCallback();
+      return this._invokeAndWait(messages, restOptions, progressCallback);
+    }
+  }
+  async *_invokeStream(messages, options) {
+    const response = await this._createResponse(messages, options);
+    console.log(`Response ID: ${response.responseId}`);
+    let lastMessageCount = 0;
+    while (true) {
+      const current = await this.responses.get(response.responseId, { wait: LONG_POLL_TIMEOUT_S });
+      const currentMessageCount = current.progress?.length || 0;
+      if (currentMessageCount > lastMessageCount && current.progress) {
+        for (let i = lastMessageCount; i < currentMessageCount; i++)
+          yield current.progress[i];
+        lastMessageCount = currentMessageCount;
+      }
+      if (current.status === "succeeded" || current.status === "failed" || current.status === "cancelled") {
+        if (current.status === "succeeded" && current.outputText) {
+          const progressEntry = {
+            ts: current.completedAt || (/* @__PURE__ */ new Date()).toISOString(),
+            state: "completed",
+            message: "Task completed successfully",
+            outputText: current.outputText
+          };
+          yield progressEntry;
+        }
+        break;
+      }
+    }
+  }
+  async _invokeAndWait(messages, options, progressCallback) {
+    const { pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, maxWaitMs = 3e5, ...createOptions } = options || {};
+    const response = await this._createResponse(messages, createOptions);
+    if (!progressCallback)
+      console.log(`Response ID: ${response.responseId}`);
+    const startTime = Date.now();
+    while (true) {
+      const current = await this.responses.get(response.responseId, { wait: LONG_POLL_TIMEOUT_S });
+      if (progressCallback)
+        progressCallback(current);
+      if (current.status === "succeeded" || current.status === "failed" || current.status === "cancelled")
+        return current;
+      if (Date.now() - startTime > maxWaitMs)
+        throw new Error(`Response ${response.responseId} timed out after ${maxWaitMs}ms`);
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  }
+  async _createResponse(messages, options) {
+    const { scope: optionScope, userId: optionUserId, ...restOptions } = options;
+    const effectiveUserId = optionUserId || this._scopedUserId;
+    let scope = optionScope || this._defaultScope;
+    if (effectiveUserId && scope === "tenant")
+      scope = "user";
+    if (scope === "user" && !effectiveUserId)
+      throw new Error("user_id is required for user scope");
+    if (scope === "tenant")
+      await this.http.warnTenantScope();
+    let messageArray;
+    if (typeof messages === "string")
+      messageArray = [{ role: "user", content: messages }];
+    else if (Array.isArray(messages))
+      messageArray = messages;
+    else
+      messageArray = [messages];
+    return this.responses.create({
+      messages: messageArray,
+      userId: effectiveUserId,
+      ...restOptions
+    });
+  }
+  // Thread methods
+  async listThreads(params) {
+    return this.threads.list(params);
+  }
+  async createThread(params) {
+    return this.threads.create(params);
+  }
+  async getThread(threadId) {
+    return this.threads.get(threadId);
+  }
+  async deleteThread(threadId) {
+    return this.threads.delete(threadId);
+  }
+  // User methods
+  async createUser(params) {
+    return this.users.create(params);
+  }
+  async getUser(userId) {
+    return this.users.get(userId);
+  }
+  async updateUser(userId, params) {
+    return this.users.update(userId, params);
+  }
+  async deleteUser(userId) {
+    return this.users.delete(userId);
+  }
+  async listUsers(params) {
+    return this.users.list(params);
+  }
+  // External API Key methods
+  async addApiKey(params) {
+    return this.externalApiKeys.create(params);
+  }
+  async listApiKeys() {
+    return this.externalApiKeys.list();
+  }
+  async getApiKey(keyId) {
+    return this.externalApiKeys.get(keyId);
+  }
+  async deleteApiKey(provider) {
+    return this.externalApiKeys.delete(provider);
+  }
+  async getApiKeyMode() {
+    return this.externalApiKeys.getMode();
+  }
+  async setApiKeyMode(mode) {
+    return this.externalApiKeys.setMode(mode);
+  }
+  // Integration methods
+  async listApps(params) {
+    return this.integrations.listApps(params);
+  }
+  async isAppEnabled(appName) {
+    return this.integrations.isAppEnabled(appName);
+  }
+  async setAppEnabled(appName, enabled) {
+    return this.integrations.setAppEnabled(appName, { enabled });
+  }
+  async initiateConnection(params) {
+    return this.integrations.initiateConnection(params);
+  }
+  async getConnectionStatus(userId, appName) {
+    return this.integrations.getConnectionStatus(userId, appName);
+  }
+  async listConnections(userId, params) {
+    return this.integrations.listConnections(userId, params);
+  }
+  async getIntegrationTools(userId, params) {
+    return this.integrations.getTools({ userId, appFilter: params?.appFilter });
+  }
+  // Model Preference methods
+  async getModelPreferences(params) {
+    return this.modelPreferences.list(params);
+  }
+  async updateModelPreferences(params) {
+    return this.modelPreferences.updateBulk(params);
+  }
+  // MCP Server methods
+  async createMcpServer(params) {
+    return this.mcpServers.create(params);
+  }
+  async getMcpServer(serverId) {
+    return this.mcpServers.get(serverId);
+  }
+  async listMcpServers(params) {
+    return this.mcpServers.list(params);
+  }
+  async updateMcpServer(serverId, params) {
+    return this.mcpServers.update(serverId, params);
+  }
+  async deleteMcpServer(serverId) {
+    return this.mcpServers.delete(serverId);
+  }
+  async listMcpServerTools(serverId) {
+    return this.mcpServers.listTools(serverId);
+  }
+  async testMcpServer(serverId) {
+    return this.mcpServers.testConnection(serverId);
+  }
+}
+function createSimpleProgressCallback() {
+  let lastStatus;
+  const seenMessages = /* @__PURE__ */ new Set();
+  return (response) => {
+    if (response.status !== lastStatus) {
+      console.log(`Status: ${response.status}`);
+      lastStatus = response.status;
+    }
+    if (response.progress) {
+      for (const entry of response.progress) {
+        const messageKey = `${entry.state}:${entry.message}`;
+        if (!seenMessages.has(messageKey)) {
+          console.log(`${entry.state.toUpperCase()}: ${entry.message}`);
+          seenMessages.add(messageKey);
+        }
+      }
+    }
+  };
+}
+
+exports.AuthenticationError = AuthenticationError;
+exports.InternalServerError = InternalServerError;
+exports.LocalFileNotSupportedError = LocalFileNotSupportedError;
+exports.LumnisClient = LumnisClient;
+exports.LumnisError = LumnisError;
+exports.NotFoundError = NotFoundError;
+exports.RateLimitError = RateLimitError;
+exports.ValidationError = ValidationError;
+exports.default = LumnisClient;