@uipath/conversational-tool 1.202.0-preview.154 → 1.202.0-preview.156

package/dist/{cas-client-41qqtt3s.js → cas-client-7jpe3zwg.js}

@@ -4,7 +4,7 @@ import {
   getLoginStatusAsync,
   getSdkUserAgentToken,
   package_default
-} from "./tool-ep93w80x.js";
+} from "./tool-shsp9fns.js";
 import"./tool-1yh8g550.js";
 
 // src/api/cas-client.ts

package/dist/{index-xzshjcwa.js → index-a3nybs0a.js}

@@ -7154,7 +7154,8 @@ var RESPONSE_TYPES = {
   JSON: "json",
   TEXT: "text",
   BLOB: "blob",
-  ARRAYBUFFER: "arraybuffer"
+  ARRAYBUFFER: "arraybuffer",
+  STREAM: "stream"
 };
 var EXTERNAL_USER_ID = "x-uipath-external-user-id";
 var CONVERSATIONAL_SURFACE_NAME = "x-uipath-conversational-surfacename";
@@ -7166,6 +7167,165 @@ var WEBSOCKET_QUERY_PARAMS = {
   CONVERSATIONAL_SURFACE_NAME,
   CONVERSATIONAL_SURFACE_VERSION
 };
+function toSearchParams(params) {
+  const searchParams = new URLSearchParams;
+  if (!params)
+    return searchParams;
+  for (const [key, value2] of Object.entries(params)) {
+    if (value2 === undefined || value2 === null)
+      continue;
+    if (Array.isArray(value2)) {
+      value2.forEach((item) => {
+        if (item !== undefined && item !== null)
+          searchParams.append(key, String(item));
+      });
+    } else {
+      searchParams.append(key, String(value2));
+    }
+  }
+  return searchParams;
+}
+var DEFAULT_RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+var DEFAULT_RETRY_METHODS = ["GET", "HEAD", "PUT", "DELETE", "OPTIONS"];
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 2,
+  initialDelayMs: 500,
+  backoffStrategy: "exponential",
+  backoffFactor: 2,
+  backoffMaxDelayMs: 30000,
+  retryableStatusCodes: DEFAULT_RETRYABLE_STATUS_CODES,
+  retryMethods: DEFAULT_RETRY_METHODS,
+  retryNetworkErrors: true,
+  respectRetryAfter: true,
+  maxRetryAfterMs: Infinity
+};
+var DEFAULT_API_CLIENT_RETRY = {
+  ...DEFAULT_RETRY_OPTIONS,
+  maxRetries: 0
+};
+function resolveRetryOptions(settings, defaults = DEFAULT_RETRY_OPTIONS) {
+  if (!settings)
+    return defaults;
+  const { retryDelay, useExponentialBackoff, ...live } = settings;
+  const resolved = { ...defaults };
+  for (const [key, value2] of Object.entries(live)) {
+    if (value2 !== undefined) {
+      resolved[key] = value2;
+    }
+  }
+  if (retryDelay !== undefined && live.initialDelayMs === undefined) {
+    resolved.initialDelayMs = retryDelay;
+  }
+  if (useExponentialBackoff !== undefined && live.backoffStrategy === undefined) {
+    resolved.backoffStrategy = useExponentialBackoff ? "exponential" : "constant";
+  }
+  return resolved;
+}
+function computeBackoffDelay(attempt, settings) {
+  const base = Math.max(0, settings.initialDelayMs);
+  let delay;
+  switch (settings.backoffStrategy) {
+    case "constant":
+      delay = base;
+      break;
+    case "linear":
+      delay = base * (attempt + 1);
+      break;
+    default:
+      delay = base * Math.pow(settings.backoffFactor, attempt);
+  }
+  return Math.min(delay, settings.backoffMaxDelayMs);
+}
+function parseRetryAfter(value2, now = Date.now()) {
+  const trimmed = value2?.trim();
+  if (!trimmed)
+    return;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date))
+    return;
+  return Math.max(0, date - now);
+}
+function wait(durationMs) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, durationMs)));
+}
+var RETRY_AFTER = "retry-after";
+function createAttemptSignal(timeoutMs, external) {
+  if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
+    return { signal: external, dispose: () => {} };
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(new Error(`Request timeout after ${timeoutMs}ms`)), timeoutMs);
+  const onExternalAbort = () => controller.abort(external?.reason);
+  if (external) {
+    if (external.aborted) {
+      controller.abort(external.reason);
+    } else {
+      external.addEventListener("abort", onExternalAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", onExternalAbort);
+    }
+  };
+}
+function delayBeforeRetry(durationMs, signal) {
+  if (!signal)
+    return wait(durationMs);
+  if (signal.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, durationMs));
+    signal.addEventListener("abort", onAbort);
+  });
+}
+async function fetchWithRetry(url2, init, options) {
+  const settings = options.retry;
+  const method = (init.method ?? "GET").toUpperCase();
+  const retriesAllowed = settings.retryMethods.includes(method) ? Math.max(0, settings.maxRetries) : 0;
+  let attempt = 0;
+  for (;; ) {
+    const { signal, dispose } = createAttemptSignal(options.timeoutMs, options.signal);
+    let response;
+    let failure;
+    try {
+      response = await fetch(url2, { ...init, signal });
+    } catch (error) {
+      failure = error;
+    } finally {
+      dispose();
+    }
+    if (options.signal?.aborted && failure !== undefined)
+      throw failure;
+    if (response && !settings.retryableStatusCodes.includes(response.status))
+      return response;
+    if (failure !== undefined && !settings.retryNetworkErrors)
+      throw failure;
+    if (attempt >= retriesAllowed) {
+      if (response)
+        return response;
+      throw failure;
+    }
+    const retryAfter = settings.respectRetryAfter && response ? parseRetryAfter(response.headers.get(RETRY_AFTER)) : undefined;
+    const delay = retryAfter !== undefined ? Math.min(retryAfter, settings.maxRetryAfterMs) : computeBackoffDelay(attempt, settings);
+    response?.body?.cancel().catch((error) => {
+      console.warn("[UiPath SDK] Could not release a discarded response body:", error);
+    });
+    await delayBeforeRetry(delay, options.signal);
+    attempt++;
+  }
+}
 
 class ApiClient {
   constructor(config, executionContext, tokenManager, clientConfig = {}) {
@@ -7200,28 +7360,16 @@ class ApiClient {
       [UIPATH_TRACEPARENT_ID]: traceparentValue,
       ...options.headers
     };
-    const searchParams = new URLSearchParams;
-    if (options.params) {
-      Object.entries(options.params).forEach(([key, value2]) => {
-        if (Array.isArray(value2)) {
-          value2.forEach((item) => searchParams.append(key, String(item)));
-        } else {
-          searchParams.append(key, String(value2));
-        }
-      });
-    }
+    const searchParams = toSearchParams(options.params);
     const fullUrl = searchParams.toString() ? `${url2}?${searchParams.toString()}` : url2;
     let body = undefined;
     if (options.body) {
       body = isFormData ? options.body : JSON.stringify(options.body);
     }
+    const retrySettings = resolveRetryOptions(options.retry ?? options.retryOptions, DEFAULT_API_CLIENT_RETRY);
+    const timeoutMs = options.timeoutMs ?? options.timeoutOptions?.timeout;
     try {
-      const response = await fetch(fullUrl, {
-        method,
-        headers,
-        body,
-        signal: options.signal
-      });
+      const response = await fetchWithRetry(fullUrl, { method, headers, body }, { retry: retrySettings, timeoutMs, signal: options.signal });
       if (!response.ok) {
         const errorInfo = await errorResponseParser.parse(response);
         throw ErrorFactory.createFromHttpStatus(response.status, errorInfo);
@@ -7685,6 +7833,12 @@ class PaginationHelpers {
     });
   }
 }
+function missingConfigMessage() {
+  if (isBrowser) {
+    return "UiPath SDK configuration not found. " + "Ensure @uipath/coded-apps plugin is set up in your bundler to inject configuration during development and build.";
+  }
+  return "UiPath SDK configuration not found. " + "In a UiPath coded function, pass the handler context: new UiPath(ctx). " + "Otherwise pass { baseUrl, orgName, tenantName, secret }, " + "or set UIPATH_BASE_URL, UIPATH_ORG_NAME, UIPATH_TENANT_NAME and UIPATH_ACCESS_TOKEN.";
+}
 var REGISTRY_KEY = Symbol.for("@uipath/sdk-internals-registry");
 var getGlobalStore = () => {
   const globalObj = globalThis;
@@ -7693,6 +7847,7 @@ var getGlobalStore = () => {
   }
   return globalObj[REGISTRY_KEY];
 };
+var looksLikeUiPath = (instance) => typeof instance.initialize === "function";
 
 class SDKInternalsRegistry {
   static get store() {
@@ -7704,6 +7859,9 @@ class SDKInternalsRegistry {
   static get(instance) {
     const internals = this.store.get(instance);
     if (!internals) {
+      if (looksLikeUiPath(instance)) {
+        throw new Error("Cannot create a service: the UiPath instance was never configured. " + missingConfigMessage());
+      }
       throw new Error("Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.");
     }
     return internals;
@@ -8027,6 +8185,16 @@ var AgentMap = {
 var UserSettingsMap = {
   ...CommonFieldMap
 };
+var ConnectionState;
+(function(ConnectionState2) {
+  ConnectionState2["Enabled"] = "Enabled";
+  ConnectionState2["Disabled"] = "Disabled";
+  ConnectionState2["Expired"] = "Expired";
+  ConnectionState2["Failed"] = "Failed";
+})(ConnectionState || (ConnectionState = {}));
+var ConnectionAuthMap = {
+  expiresAt: "expiresTime"
+};
 var AUTOPILOT_BASE = "autopilotforeveryone_";
 var API_VERSION = "v1";
 var CONVERSATION_ENDPOINTS = {
@@ -8050,7 +8218,9 @@ var ATTACHMENT_ENDPOINTS = {
 };
 var AGENT_ENDPOINTS = {
   LIST: `${AUTOPILOT_BASE}/api/${API_VERSION}/agent`,
-  GET: (folderId, agentId) => `${AUTOPILOT_BASE}/api/${API_VERSION}/agent/${folderId}/${agentId}`
+  GET: (folderId, agentId) => `${AUTOPILOT_BASE}/api/${API_VERSION}/agent/${folderId}/${agentId}`,
+  CONNECTIONS: (folderId, agentId) => `${AUTOPILOT_BASE}/api/${API_VERSION}/agent/${folderId}/${agentId}/connections`,
+  CONNECTION_AUTH: `${AUTOPILOT_BASE}/api/${API_VERSION}/agent/connections/auth`
 };
 var USER_ENDPOINTS = {
   SETTINGS: `${AUTOPILOT_BASE}/api/${API_VERSION}/user/settings`
@@ -10772,6 +10942,29 @@ class ConversationalAgentService extends BaseService {
     const mimeType = resolveCitationMimeType(source, blob.type);
     return mimeType && mimeType !== blob.type ? blob.slice(0, blob.size, mimeType) : blob;
   }
+  async getAvailableConnections(agentId, folderId) {
+    const response = await this.get(AGENT_ENDPOINTS.CONNECTIONS(folderId, agentId));
+    return response.data;
+  }
+  async updateConnectionSelections(agentId, folderId, request) {
+    const response = await this.put(AGENT_ENDPOINTS.CONNECTIONS(folderId, agentId), request);
+    return response.data;
+  }
+  async getAddConnectionUrl(item) {
+    try {
+      const { authUrl } = await this.fetchConnectionAuthUrl(item.connectorKey);
+      return authUrl;
+    } catch {
+      return item.connectionsUrl ?? item.configurationUrl ?? null;
+    }
+  }
+  async getConnectionAuthUrl(connectorKey) {
+    return this.fetchConnectionAuthUrl(connectorKey);
+  }
+  async fetchConnectionAuthUrl(connectorKey) {
+    const response = await this.post(AGENT_ENDPOINTS.CONNECTION_AUTH, { connectorKey });
+    return transformData(response.data, ConnectionAuthMap);
+  }
   async getFeatureFlags() {
     const response = await this.get(FEATURE_ENDPOINTS.FEATURE_FLAGS);
     return response.data;
@@ -10786,6 +10979,18 @@ __decorate([
 __decorate([
   track("ConversationalAgent.DownloadCitationSource")
 ], ConversationalAgentService.prototype, "downloadCitationSource", null);
+__decorate([
+  track("ConversationalAgent.GetAvailableConnections")
+], ConversationalAgentService.prototype, "getAvailableConnections", null);
+__decorate([
+  track("ConversationalAgent.UpdateConnectionSelections")
+], ConversationalAgentService.prototype, "updateConnectionSelections", null);
+__decorate([
+  track("ConversationalAgent.GetAddConnectionUrl")
+], ConversationalAgentService.prototype, "getAddConnectionUrl", null);
+__decorate([
+  track("ConversationalAgent.GetConnectionAuthUrl")
+], ConversationalAgentService.prototype, "getConnectionAuthUrl", null);
 export {
   AgentMap,
   AsyncInputStreamEventHelper,
@@ -10793,6 +10998,8 @@ export {
   AsyncToolCallEventHelper,
   AsyncToolCallEventHelperImpl,
   CitationErrorType,
+  ConnectionAuthMap,
+  ConnectionState,
   ContentPartEventHelper,
   ContentPartEventHelperImpl,
   ContentPartHelper,
@@ -10844,4 +11051,4 @@ export {
   transformMessage
 };
 
-//# debugId=EFB6E7334C72C1DA64756E2164756E21
+//# debugId=C2A4B4AA6694029164756E2164756E21

package/dist/index.js

@@ -2,11 +2,11 @@
 import {
   metadata,
   registerCommands
-} from "./tool-nd7q6550.js";
+} from "./tool-s6st9bcb.js";
 import"./tool-nkyhbf79.js";
 import {
   Command
-} from "./tool-ep93w80x.js";
+} from "./tool-shsp9fns.js";
 import"./tool-mpvp5rqs.js";
 import"./tool-1yh8g550.js";