@lpextend/node-sdk 1.1.2 → 1.1.4

package/dist/index.js

@@ -184,6 +184,37 @@ var DomainResolver = class {
         account: this.accountId,
         service: "promptlibrary",
         baseURI: `${this.geo}.promptlibrary.liveperson.net`
+      },
+      // Conversation Builder domains (aliases for consistency with CB service naming)
+      {
+        account: this.accountId,
+        service: "cbBotPlatform",
+        baseURI: `${this.region}.bc-platform.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "cbIbc",
+        baseURI: `${this.region}.bc-nlu.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "cbKb",
+        baseURI: `${this.region}.bc-kb.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "cbMonitoring",
+        baseURI: `${this.region}.bc-mgmt.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "cbExternalIntegrations",
+        baseURI: `${this.region}.bc-intg.liveperson.net`
+      },
+      {
+        account: this.accountId,
+        service: "cbAiSearch",
+        baseURI: `${this.region}.kai.liveperson.net`
       }
     ];
   }
@@ -1688,6 +1719,524 @@ var LPPromptsAPI = class {
   }
 };
 
+// src/api/conversation-builder.api.ts
+var ConversationBuilderAPI = class {
+  constructor(accountId, debug = false, timeout = 3e4) {
+    this.accountId = accountId;
+    this.credentials = null;
+    this.domainResolver = new DomainResolver(accountId);
+    this.debug = debug;
+    this.timeout = timeout;
+    this.botGroups = new BotGroupsAPI(this);
+    this.bots = new BotsAPI(this);
+    this.dialogs = new DialogsAPI(this);
+    this.interactions = new InteractionsAPI(this);
+    this.nluDomains = new NLUDomainsAPI(this);
+    this.knowledgeBases = new KnowledgeBasesAPI(this);
+    this.botAgents = new BotAgentsAPI(this);
+    this.integrations = new IntegrationsAPI(this);
+  }
+  /**
+   * Set CB authentication credentials
+   * Must be called before making any CB API calls
+   */
+  setCredentials(credentials) {
+    this.credentials = credentials;
+    this.log("CB credentials set", { organizationId: credentials.organizationId });
+  }
+  /**
+   * Check if credentials are set
+   */
+  hasCredentials() {
+    return this.credentials !== null;
+  }
+  /**
+   * Get the current credentials
+   * @throws If credentials not set
+   */
+  getCredentials() {
+    if (!this.credentials) {
+      throw new LPExtendSDKError(
+        "CB credentials not set. Call setCredentials() first or use sentinel.authenticateCB().",
+        ErrorCodes.UNAUTHORIZED
+      );
+    }
+    return this.credentials;
+  }
+  /**
+   * Get the account ID
+   */
+  getAccountId() {
+    return this.accountId;
+  }
+  /**
+   * Get domain for a CB service
+   */
+  async getDomain(service) {
+    const domain = await this.domainResolver.getDomain(service);
+    if (!domain) {
+      throw new LPExtendSDKError(
+        `Could not resolve domain for CB service: ${service}`,
+        ErrorCodes.API_ERROR
+      );
+    }
+    return domain;
+  }
+  /**
+   * Make authenticated request to CB API
+   */
+  async request(service, path, options = {}) {
+    const { cbToken, organizationId } = this.getCredentials();
+    const domain = await this.getDomain(service);
+    const method = options.method || "GET";
+    let url = `https://${domain}${path}`;
+    if (options.params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(options.params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      });
+      const paramString = searchParams.toString();
+      if (paramString) {
+        url += (url.includes("?") ? "&" : "?") + paramString;
+      }
+    }
+    const headers = {
+      "Accept": "application/json",
+      "Content-Type": "application/json; charset=utf-8",
+      "authorization": cbToken,
+      "organizationid": organizationId
+    };
+    this.log(`${method} ${url}`, { service });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({ message: "Unknown error" }));
+        throw new LPExtendSDKError(
+          `CB API Error: ${response.status} - ${errorBody.message || response.statusText}`,
+          ErrorCodes.API_ERROR,
+          response.status,
+          errorBody
+        );
+      }
+      const contentType = response.headers.get("content-type");
+      if (!contentType?.includes("application/json") || response.status === 204) {
+        return void 0;
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new LPExtendSDKError("CB API request timeout", ErrorCodes.TIMEOUT);
+      }
+      if (error instanceof LPExtendSDKError) {
+        throw error;
+      }
+      throw new LPExtendSDKError(
+        `CB API request failed: ${error.message}`,
+        ErrorCodes.API_ERROR
+      );
+    }
+  }
+  /**
+   * Debug logging
+   */
+  log(...args) {
+    if (this.debug) {
+      console.log("[LP-Extend-SDK:CB]", ...args);
+    }
+  }
+};
+var BotGroupsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get all bot groups
+   */
+  async getAll(params) {
+    const queryParams = {};
+    if (params?.expandAll) {
+      queryParams["expand-all"] = true;
+    } else {
+      queryParams.page = params?.page ?? 1;
+      queryParams.size = params?.size ?? 100;
+    }
+    return this.cb.request("cbBotPlatform", "/bot-groups", { params: queryParams });
+  }
+  /**
+   * Get bots by group
+   */
+  async getBots(params) {
+    const queryParams = {
+      "sort-by": params?.sortBy ?? "botName:asc",
+      page: params?.page ?? 1,
+      size: params?.size ?? 10,
+      "bot-group-id": params?.botGroupId ?? "un_assigned"
+    };
+    return this.cb.request("cbBotPlatform", "/bot-groups/bots", { params: queryParams });
+  }
+};
+var BotsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get all bots (legacy chatbots endpoint)
+   */
+  async getAll() {
+    return this.cb.request("botPlatform", "/bot-platform-manager-0.1/chatbots");
+  }
+  /**
+   * Get chatbot by ID
+   */
+  async getById(chatBotId) {
+    return this.cb.request("cbBotPlatform", "/chatbots", {
+      params: { chatBotId }
+    });
+  }
+  /**
+   * Get global functions for a bot
+   */
+  async getGlobalFunctions(botId) {
+    return this.cb.request("cbBotPlatform", `/bot/${botId}/globalFunctions`);
+  }
+  /**
+   * Get LP app credentials for a bot
+   */
+  async getLPAppCredentials(chatBotId) {
+    return this.cb.request("cbBotPlatform", "/auth/liveperson/app", {
+      params: { chatBotId }
+    });
+  }
+  /**
+   * Get bot environment variables
+   */
+  async getEnvironment() {
+    const data = await this.cb.request("cbBotPlatform", "/auth/botenvironment/");
+    if (Array.isArray(data)) {
+      return { success: true, successResult: data };
+    }
+    return data;
+  }
+};
+var DialogsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get all dialogs for a bot
+   */
+  async getByBotId(botId) {
+    return this.cb.request("cbBotPlatform", `/bots/${botId}/dialog/`);
+  }
+  /**
+   * Get dialog template summaries
+   */
+  async getTemplateSummary() {
+    return this.cb.request("cbBotPlatform", "/dialog/template/summary");
+  }
+};
+var InteractionsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get all interactions for a bot
+   */
+  async getByBotId(botId) {
+    return this.cb.request("cbBotPlatform", `/chat/${botId}/interaction/`);
+  }
+};
+var NLUDomainsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get all NLU domains for the organization
+   */
+  async getAll() {
+    return this.cb.request("cbIbc", "/api/cb/nlu/v1/domains/getByOrgId");
+  }
+  /**
+   * Get intents for a domain
+   */
+  async getIntents(domainId) {
+    const data = await this.cb.request("cbIbc", `/api/cb/nlu/v1/domains/${domainId}/intents`);
+    if (Array.isArray(data)) {
+      return { success: true, successResult: data };
+    }
+    return data;
+  }
+};
+var KnowledgeBasesAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get all knowledge bases
+   */
+  async getAll(includeMetrics = true) {
+    return this.cb.request("cbKb", "/knowledgeDataSource", {
+      params: { includeMetrics }
+    });
+  }
+  /**
+   * Get knowledge base by ID
+   */
+  async getById(kbId, includeMetrics = true) {
+    return this.cb.request("cbKb", `/knowledgeDataSource/${kbId}`, {
+      params: { includeMetrics }
+    });
+  }
+  /**
+   * Get content sources for a knowledge base
+   */
+  async getContentSources(kbId, includeKmsRecipeDetails = true) {
+    return this.cb.request("cbKb", `/kb/${kbId}/content_sources`, {
+      params: { includeKmsRecipeDetails }
+    });
+  }
+  /**
+   * Get articles for a knowledge base
+   */
+  async getArticles(kbId, params) {
+    const body = {
+      page: params?.page ?? 1,
+      size: params?.size ?? 20,
+      sortAscByLastModificationTime: params?.sortAscByLastModificationTime ?? false,
+      articleIds: params?.articleIds ?? []
+    };
+    return this.cb.request("cbKb", `/kb/${kbId}/articles`, {
+      method: "POST",
+      body,
+      params: { includeConflictingDetails: params?.includeConflictingDetails ?? true }
+    });
+  }
+  /**
+   * Search knowledge base using KAI
+   */
+  async search(kbId, searchRequest) {
+    try {
+      return await this.cb.request("cbAiSearch", `/v1/account/${this.cb.getAccountId()}/kb/${kbId}/search`, {
+        method: "POST",
+        body: searchRequest
+      });
+    } catch {
+      return this.cb.request("cbKb", `/kb/${kbId}/search`, {
+        method: "POST",
+        body: searchRequest
+      });
+    }
+  }
+  /**
+   * Get KAI On-Demand configurations
+   */
+  async getOnDemandConfigs() {
+    return this.cb.request("cbKb", "/on-demand/configs");
+  }
+  /**
+   * Get default prompt for KAI
+   */
+  async getDefaultPrompt() {
+    return this.cb.request("cbKb", "/default-prompt");
+  }
+  /**
+   * Get consumer query metrics for a knowledge base
+   *
+   * Retrieves answered and/or unanswered query metrics within a date range.
+   * Note: The API only supports 7-day ranges. For longer ranges, use getConsumerQueryMetricsExtended().
+   *
+   * @param params - Query parameters including kbId, startTime, endTime, and eventType
+   * @returns Promise resolving to consumer query metrics
+   *
+   * @example
+   * ```typescript
+   * const metrics = await sdk.conversationBuilder.knowledgeBases.getConsumerQueryMetrics({
+   *   kbId: 'kb-123',
+   *   startTime: Date.now() - 7 * 24 * 60 * 60 * 1000, // 7 days ago
+   *   endTime: Date.now(),
+   *   eventType: ['EVENT_KB_UN_ANSWERED'],
+   * });
+   * ```
+   */
+  async getConsumerQueryMetrics(params) {
+    const body = {
+      startTime: String(params.startTime),
+      endTime: String(params.endTime),
+      eventType: params.eventType,
+      kbId: params.kbId
+    };
+    return this.cb.request("cbKb", "/kb/consumerQueryMetrics", {
+      method: "POST",
+      body
+    });
+  }
+  /**
+   * Get consumer query metrics for extended date ranges (up to 3 months)
+   *
+   * Automatically iterates through 7-day chunks to retrieve all metrics within
+   * the specified date range. Useful for historical analysis beyond the 7-day API limit.
+   *
+   * @param params - Extended query parameters including startDate, endDate, kbId, and eventType
+   * @returns Promise resolving to aggregated consumer query metrics from all chunks
+   *
+   * @example
+   * ```typescript
+   * const metrics = await sdk.conversationBuilder.knowledgeBases.getConsumerQueryMetricsExtended({
+   *   kbId: 'kb-123',
+   *   startDate: new Date('2024-01-01'),
+   *   endDate: new Date('2024-03-01'),
+   *   eventType: ['EVENT_KB_ANSWERED', 'EVENT_KB_UN_ANSWERED'],
+   *   onProgress: (completed, total) => console.log(`${completed}/${total} chunks processed`),
+   * });
+   * ```
+   */
+  async getConsumerQueryMetricsExtended(params) {
+    const { startDate, endDate, eventType, kbId, onProgress } = params;
+    const startMs = typeof startDate === "number" ? startDate : startDate.getTime();
+    const endMs = typeof endDate === "number" ? endDate : endDate.getTime();
+    const maxRangeMs = 90 * 24 * 60 * 60 * 1e3;
+    if (endMs - startMs > maxRangeMs) {
+      throw new LPExtendSDKError(
+        "Date range exceeds maximum of 90 days. Please use a smaller range.",
+        ErrorCodes.INVALID_CONFIG
+      );
+    }
+    const chunkSizeMs = 7 * 24 * 60 * 60 * 1e3;
+    const chunks = [];
+    let chunkStart = startMs;
+    while (chunkStart < endMs) {
+      const chunkEnd = Math.min(chunkStart + chunkSizeMs, endMs);
+      chunks.push({ start: chunkStart, end: chunkEnd });
+      chunkStart = chunkEnd;
+    }
+    const allMetrics = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      try {
+        const response = await this.getConsumerQueryMetrics({
+          kbId,
+          startTime: chunk.start,
+          endTime: chunk.end,
+          eventType
+        });
+        if (response.data && Array.isArray(response.data)) {
+          allMetrics.push(...response.data);
+        }
+      } catch (error) {
+        console.warn(`Failed to fetch metrics for chunk ${i + 1}/${chunks.length}:`, error);
+      }
+      if (onProgress) {
+        onProgress(i + 1, chunks.length);
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const uniqueMetrics = allMetrics.filter((metric) => {
+      const key = metric.id || `${metric.consumerQuery}-${metric.timestamp}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+    return uniqueMetrics;
+  }
+};
+var BotAgentsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get bot instance status
+   */
+  async getInstanceStatus(botId) {
+    return this.cb.request("cbMonitoring", `/sysadmin/nodejs/instance/status-v2/${botId}`);
+  }
+  /**
+   * Start a bot agent
+   */
+  async start(botId, lpAccountId, lpAccountUser) {
+    return this.cb.request("cbMonitoring", `/sysadmin/nodejs/instance/start/${botId}`, {
+      method: "PUT",
+      body: { lpAccountId, lpAccountUser }
+    });
+  }
+  /**
+   * Stop a bot agent
+   */
+  async stop(botId, lpAccountId, lpAccountUser) {
+    return this.cb.request("cbMonitoring", `/sysadmin/nodejs/instance/stop/${botId}`, {
+      method: "PUT",
+      body: { lpAccountId, lpAccountUser }
+    });
+  }
+  /**
+   * Get all bot agents status
+   */
+  async getAllStatus(params) {
+    return this.cb.request("cbMonitoring", "/sysadmin/nodejs/instance/status", {
+      params: { environment: params?.environment ?? "PRODUCTION" }
+    });
+  }
+  /**
+   * Get PCS bots status
+   */
+  async getPCSStatus(params) {
+    return this.cb.request("cbMonitoring", "/sysadmin/nodejs/instance/pcs/status", {
+      params: { showBotsData: params?.showBotsData ?? true }
+    });
+  }
+  /**
+   * Get bot users
+   */
+  async getBotUsers() {
+    return this.cb.request("cbExternalIntegrations", `/live-engage-service-0.1/le/accounts/${this.cb.getAccountId()}/bot_users`);
+  }
+  /**
+   * Add a bot agent
+   */
+  async addAgent(lpUserId, chatBotId, request) {
+    return this.cb.request("cbExternalIntegrations", `/live-engage-service-0.1/le/accounts/${this.cb.getAccountId()}/bot_users/${lpUserId}`, {
+      method: "POST",
+      body: request,
+      params: { chatBotId }
+    });
+  }
+};
+var IntegrationsAPI = class {
+  constructor(cb) {
+    this.cb = cb;
+  }
+  /**
+   * Get responders for a chatbot
+   */
+  async getResponders(chatBotId) {
+    return this.cb.request("cbBotPlatform", "/responder", {
+      params: { chatBotId }
+    });
+  }
+  /**
+   * Get LP skills
+   */
+  async getLPSkills() {
+    return this.cb.request("cbExternalIntegrations", `/live-engage-service-0.1/le/accounts/${this.cb.getAccountId()}/skills`);
+  }
+  /**
+   * Get credentials
+   */
+  async getCredentials() {
+    return this.cb.request("cbExternalIntegrations", "/auth-service-0.1/credentials");
+  }
+};
+
 // src/sdk.ts
 var LPExtendSDK = class {
   /**
@@ -1720,6 +2269,7 @@ var LPExtendSDK = class {
     this.messaging = new MessagingAPI(this.http);
     this.sentinel = new SentinelAPI(this.http);
     this.prompts = new LPPromptsAPI(this.http);
+    this.conversationBuilder = new ConversationBuilderAPI(config.accountId, this.debug, timeout);
     this.log("SDK initialized with scopes:", this.grantedScopes);
   }
   /**
@@ -1768,9 +2318,9 @@ async function createSDK(config) {
   if (!config.accountId) {
     throw new LPExtendSDKError("accountId is required", ErrorCodes.INVALID_CONFIG);
   }
-  if (!config.accessToken && !config.extendToken && !config.shellToken) {
+  if (!config.accessToken && !config.extendToken && !config.shellToken && !config.apiKey) {
     throw new LPExtendSDKError(
-      "Either accessToken, extendToken, or shellToken is required",
+      "Either accessToken, apiKey, extendToken, or shellToken is required",
       ErrorCodes.INVALID_CONFIG
     );
   }
@@ -1778,7 +2328,9 @@ async function createSDK(config) {
   const timeout = config.timeout ?? 3e4;
   let shellBaseUrl = config.shellBaseUrl;
   if (!shellBaseUrl) {
-    if (typeof window !== "undefined") {
+    if (typeof process !== "undefined" && process.env?.LPEXTEND_SHELL_URL) {
+      shellBaseUrl = process.env.LPEXTEND_SHELL_URL;
+    } else if (typeof window !== "undefined") {
       try {
         if (window.self !== window.top && document.referrer) {
           const url = new URL(document.referrer);
@@ -1787,15 +2339,109 @@ async function createSDK(config) {
       } catch {
       }
       shellBaseUrl = shellBaseUrl || window.location.origin;
-    } else {
+    } else if (config.apiKey || config.extendToken || config.shellToken) {
       throw new LPExtendSDKError(
-        "shellBaseUrl is required in non-browser environments",
+        "shellBaseUrl is required when using apiKey, extendToken, or shellToken in non-browser environments. Set LPEXTEND_SHELL_URL environment variable or pass shellBaseUrl in config.",
         ErrorCodes.INVALID_CONFIG
       );
     }
   }
   let accessToken = config.accessToken;
-  if (!accessToken && config.extendToken) {
+  if (!accessToken && config.apiKey && config.extendToken) {
+    const verifyUrl = `${shellBaseUrl}/api/v1/apps/verify`;
+    if (debug) {
+      console.log("[LP-Extend-SDK] Verifying ExtendJWT with API key");
+      console.log("[LP-Extend-SDK] Shell URL:", shellBaseUrl);
+      console.log("[LP-Extend-SDK] Verify URL:", verifyUrl);
+      console.log("[LP-Extend-SDK] API Key:", config.apiKey.substring(0, 20) + "...");
+      console.log("[LP-Extend-SDK] ExtendToken length:", config.extendToken.length);
+    }
+    const authController = new AbortController();
+    const authTimeoutId = setTimeout(() => authController.abort(), timeout);
+    try {
+      const authResponse = await fetch(verifyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-LPExtend-API-Key": config.apiKey
+        },
+        body: JSON.stringify({
+          token: config.extendToken
+        }),
+        signal: authController.signal
+      });
+      clearTimeout(authTimeoutId);
+      if (!authResponse.ok) {
+        const errorData = await authResponse.json().catch(() => ({}));
+        if (authResponse.status === 401) {
+          throw new LPExtendSDKError(
+            errorData.message || "Invalid API key or ExtendJWT",
+            ErrorCodes.UNAUTHORIZED,
+            authResponse.status,
+            errorData
+          );
+        }
+        if (authResponse.status === 403) {
+          throw new LPExtendSDKError(
+            errorData.message || "App not authorized for this account",
+            ErrorCodes.APP_NOT_REGISTERED,
+            authResponse.status,
+            errorData
+          );
+        }
+        throw new LPExtendSDKError(
+          errorData.message || `Token verification failed: ${authResponse.status}`,
+          ErrorCodes.API_ERROR,
+          authResponse.status,
+          errorData
+        );
+      }
+      const authData = await authResponse.json();
+      accessToken = authData.lpAccessToken;
+      if (debug) {
+        console.log("[LP-Extend-SDK] ExtendJWT verified with API key");
+        console.log("[LP-Extend-SDK] User:", authData.user?.lpUserId, "Account:", authData.user?.lpAccountId);
+        console.log("[LP-Extend-SDK] Allowed APIs:", authData.allowedApis);
+      }
+      const resolvedConfig = { ...config, accessToken };
+      const initResult = {
+        appId: config.appId,
+        accountId: authData.user?.lpAccountId || config.accountId,
+        grantedScopes: authData.allowedApis || [],
+        appName: config.appId,
+        version: "1.0.0"
+      };
+      return new LPExtendSDK(resolvedConfig, initResult);
+    } catch (error) {
+      clearTimeout(authTimeoutId);
+      if (debug) {
+        console.error("[LP-Extend-SDK] ExtendJWT verification error:", {
+          name: error.name,
+          message: error.message,
+          cause: error.cause?.message || error.cause,
+          verifyUrl
+        });
+      }
+      if (error instanceof LPExtendSDKError) {
+        throw error;
+      }
+      if (error.name === "AbortError") {
+        throw new LPExtendSDKError("Token verification timeout", ErrorCodes.TIMEOUT);
+      }
+      const errorMessage = error.cause?.message || error.message;
+      throw new LPExtendSDKError(
+        `ExtendJWT verification failed: ${errorMessage}`,
+        ErrorCodes.INIT_FAILED
+      );
+    }
+  }
+  if (!accessToken && config.apiKey && !config.extendToken) {
+    throw new LPExtendSDKError(
+      "API key authentication requires extendToken. The ExtendJWT is passed from the shell to your app when opened in an iframe.",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  if (!accessToken && config.extendToken && !config.apiKey) {
     if (debug) {
       console.log("[LP-Extend-SDK] Verifying ExtendJWT with shell");
     }
@@ -1838,6 +2484,20 @@ async function createSDK(config) {
         console.log("[LP-Extend-SDK] ExtendJWT verified, got LP access token");
         console.log("[LP-Extend-SDK] User:", authData.lpUserId, "Account:", authData.lpAccountId);
       }
+      const grantedScopes = config.scopes || ["*"];
+      if (debug) {
+        console.log("[LP-Extend-SDK] ExtendJWT auth grants all scopes:", grantedScopes);
+        console.log("[LP-Extend-SDK] SDK will call LP APIs directly");
+      }
+      const resolvedConfig = { ...config, accessToken };
+      const initResult = {
+        appId: config.appId,
+        accountId: config.accountId,
+        grantedScopes,
+        appName: config.appId,
+        version: "1.0.0"
+      };
+      return new LPExtendSDK(resolvedConfig, initResult);
     } catch (error) {
       clearTimeout(extendTimeoutId);
       if (error instanceof LPExtendSDKError) {
@@ -2002,6 +2662,51 @@ async function createSDK(config) {
 async function initializeSDK(config) {
   return createSDK(config);
 }
+async function createSDKFromEnv(extendToken) {
+  const apiKey = process.env.LPEXTEND_API_KEY;
+  const appId = process.env.APP_ID;
+  const accountId = process.env.LP_ACCOUNT_ID;
+  const shellBaseUrl = process.env.LPEXTEND_SHELL_URL;
+  const debug = process.env.LPEXTEND_DEBUG === "true";
+  if (!apiKey) {
+    throw new LPExtendSDKError(
+      "LPEXTEND_API_KEY environment variable is required",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  if (!appId) {
+    throw new LPExtendSDKError(
+      "APP_ID environment variable is required",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  if (!accountId) {
+    throw new LPExtendSDKError(
+      "LP_ACCOUNT_ID environment variable is required",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  if (!shellBaseUrl) {
+    throw new LPExtendSDKError(
+      "LPEXTEND_SHELL_URL environment variable is required",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  if (!extendToken) {
+    throw new LPExtendSDKError(
+      "extendToken is required. This is passed from the shell to your app when opened.",
+      ErrorCodes.INVALID_CONFIG
+    );
+  }
+  return createSDK({
+    appId,
+    accountId,
+    apiKey,
+    extendToken,
+    shellBaseUrl,
+    debug
+  });
+}
 var VERSION = "1.0.0";
 var Scopes = {
   // Account Configuration
@@ -2123,15 +2828,23 @@ exports.AgentActivityAPI = AgentActivityAPI;
 exports.AgentGroupsAPI = AgentGroupsAPI;
 exports.AgentMetricsAPI = AgentMetricsAPI;
 exports.AutomaticMessagesAPI = AutomaticMessagesAPI;
+exports.BotAgentsAPI = BotAgentsAPI;
+exports.BotGroupsAPI = BotGroupsAPI;
+exports.BotsAPI = BotsAPI;
 exports.CampaignsAPI = CampaignsAPI;
 exports.CategoriesAPI = CategoriesAPI;
 exports.ConnectToMessagingAPI = ConnectToMessagingAPI;
+exports.ConversationBuilderAPI = ConversationBuilderAPI;
 exports.ConversationsAPI = ConversationsAPI;
+exports.DialogsAPI = DialogsAPI;
 exports.EngagementsAPI = EngagementsAPI;
 exports.ErrorCodes = ErrorCodes;
 exports.EvaluatorsAPI = EvaluatorsAPI;
 exports.FlowsAPI = FlowsAPI;
 exports.GeneratorsAPI = GeneratorsAPI;
+exports.IntegrationsAPI = IntegrationsAPI;
+exports.InteractionsAPI = InteractionsAPI;
+exports.KnowledgeBasesAPI = KnowledgeBasesAPI;
 exports.KnowledgebasesAPI = KnowledgebasesAPI;
 exports.LOBsAPI = LOBsAPI;
 exports.LPExtendSDK = LPExtendSDK;
@@ -2140,6 +2853,7 @@ exports.LPPromptsAPI = LPPromptsAPI;
 exports.MessagingAPI = MessagingAPI;
 exports.MessagingHistoryAPI = MessagingHistoryAPI;
 exports.MessagingOperationsAPI = MessagingOperationsAPI;
+exports.NLUDomainsAPI = NLUDomainsAPI;
 exports.OutboundReportingAPI = OutboundReportingAPI;
 exports.PredefinedContentAPI = PredefinedContentAPI;
 exports.ProfilesAPI = ProfilesAPI;
@@ -2156,6 +2870,7 @@ exports.UsersAPI = UsersAPI;
 exports.VERSION = VERSION;
 exports.WorkingHoursAPI = WorkingHoursAPI;
 exports.createSDK = createSDK;
+exports.createSDKFromEnv = createSDKFromEnv;
 exports.getShellToken = getShellToken;
 exports.initializeSDK = initializeSDK;
 //# sourceMappingURL=index.js.map