@elqnt/agents 3.0.5 → 3.2.0

package/dist/chunk-RGVWAFZP.js

@@ -0,0 +1,771 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkIUKM3T2Sjs = require('./chunk-IUKM3T2S.js');
+
+// hooks/index.ts
+var _react = require('react');
+
+// hooks/use-async.ts
+
+function useAsync(asyncFn, options) {
+  const [error, setError] = _react.useState.call(void 0, null);
+  const requestCountRef = _react.useRef.call(void 0, 0);
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const execute = _react.useCallback.call(void 0, 
+    async (...args) => {
+      requestCountRef.current += 1;
+      setLoading(true);
+      setError(null);
+      try {
+        return await asyncFn(...args);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "An error occurred";
+        setError(message);
+        _optionalChain([options, 'optionalAccess', _ => _.onError, 'optionalCall', _2 => _2(message)]);
+        throw err;
+      } finally {
+        requestCountRef.current -= 1;
+        if (requestCountRef.current === 0) {
+          setLoading(false);
+        }
+      }
+    },
+    [asyncFn, options]
+  );
+  const clearError = _react.useCallback.call(void 0, () => setError(null), []);
+  return { execute, loading, error, clearError };
+}
+function useApiAsync(asyncFn, extractor, defaultValue, options) {
+  const [error, setError] = _react.useState.call(void 0, null);
+  const requestCountRef = _react.useRef.call(void 0, 0);
+  const [loading, setLoading] = _react.useState.call(void 0, false);
+  const execute = _react.useCallback.call(void 0, 
+    async (...args) => {
+      requestCountRef.current += 1;
+      setLoading(true);
+      setError(null);
+      try {
+        const response = await asyncFn(...args);
+        if (response.error) {
+          setError(response.error);
+          _optionalChain([options, 'optionalAccess', _3 => _3.onError, 'optionalCall', _4 => _4(response.error)]);
+          return defaultValue;
+        }
+        return response.data ? extractor(response.data) : defaultValue;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "An error occurred";
+        setError(message);
+        _optionalChain([options, 'optionalAccess', _5 => _5.onError, 'optionalCall', _6 => _6(message)]);
+        return defaultValue;
+      } finally {
+        requestCountRef.current -= 1;
+        if (requestCountRef.current === 0) {
+          setLoading(false);
+        }
+      }
+    },
+    [asyncFn, extractor, defaultValue, options]
+  );
+  const clearError = _react.useCallback.call(void 0, () => setError(null), []);
+  return { execute, loading, error, clearError };
+}
+
+// hooks/use-options-ref.ts
+
+function useOptionsRef(options) {
+  const optionsRef = _react.useRef.call(void 0, options);
+  _react.useEffect.call(void 0, () => {
+    optionsRef.current = options;
+  }, [options]);
+  return optionsRef;
+}
+
+// hooks/index.ts
+function useAgents(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listAgents, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listAgentsApi.call(void 0, optionsRef.current),
+    (data) => data.agents,
+    []
+  );
+  const { execute: listAgentSummaries, loading: listSummaryLoading, error: listSummaryError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listAgentsSummaryApi.call(void 0, optionsRef.current),
+    (data) => data.agents,
+    []
+  );
+  const { execute: getAgent, loading: getLoading, error: getError } = useApiAsync(
+    (agentId) => _chunkIUKM3T2Sjs.getAgentApi.call(void 0, agentId, optionsRef.current),
+    (data) => data.agent || null,
+    null
+  );
+  const { execute: createAgent, loading: createLoading, error: createError } = useApiAsync(
+    (agent) => _chunkIUKM3T2Sjs.createAgentApi.call(void 0, agent, optionsRef.current),
+    (data) => data.agent || null,
+    null
+  );
+  const { execute: updateAgent, loading: updateLoading, error: updateError } = useApiAsync(
+    (agentId, agent) => _chunkIUKM3T2Sjs.updateAgentApi.call(void 0, agentId, agent, optionsRef.current),
+    (data) => data.agent || null,
+    null
+  );
+  const { execute: deleteAgent, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (agentId) => _chunkIUKM3T2Sjs.deleteAgentApi.call(void 0, agentId, optionsRef.current),
+    () => true,
+    false
+  );
+  const { execute: getDefaultAgent, loading: defaultLoading, error: defaultError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.getDefaultAgentApi.call(void 0, optionsRef.current),
+    (data) => data.agent || null,
+    null
+  );
+  const loading = listLoading || listSummaryLoading || getLoading || createLoading || updateLoading || deleteLoading || defaultLoading;
+  const error = listError || listSummaryError || getError || createError || updateError || deleteError || defaultError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listAgents,
+      listAgentSummaries,
+      getAgent,
+      createAgent,
+      updateAgent,
+      deleteAgent,
+      getDefaultAgent
+    }),
+    [loading, error, listAgents, listAgentSummaries, getAgent, createAgent, updateAgent, deleteAgent, getDefaultAgent]
+  );
+}
+function useSkills(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listSkills, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listSkillsApi.call(void 0, optionsRef.current),
+    (data) => data.skills,
+    []
+  );
+  const { execute: getSkill, loading: getLoading, error: getError } = useApiAsync(
+    (skillId) => _chunkIUKM3T2Sjs.getSkillApi.call(void 0, skillId, optionsRef.current),
+    (data) => data.skill || null,
+    null
+  );
+  const { execute: createSkill, loading: createLoading, error: createError } = useApiAsync(
+    (skill) => _chunkIUKM3T2Sjs.createSkillApi.call(void 0, skill, optionsRef.current),
+    (data) => data.skill || null,
+    null
+  );
+  const { execute: updateSkill, loading: updateLoading, error: updateError } = useApiAsync(
+    (skillId, skill) => _chunkIUKM3T2Sjs.updateSkillApi.call(void 0, skillId, skill, optionsRef.current),
+    (data) => data.skill || null,
+    null
+  );
+  const { execute: deleteSkill, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (skillId) => _chunkIUKM3T2Sjs.deleteSkillApi.call(void 0, skillId, optionsRef.current),
+    () => true,
+    false
+  );
+  const { execute: getCategories, loading: categoriesLoading, error: categoriesError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.getSkillCategoriesApi.call(void 0, optionsRef.current),
+    (data) => data.categories,
+    []
+  );
+  const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading || categoriesLoading;
+  const error = listError || getError || createError || updateError || deleteError || categoriesError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listSkills,
+      getSkill,
+      createSkill,
+      updateSkill,
+      deleteSkill,
+      getCategories
+    }),
+    [loading, error, listSkills, getSkill, createSkill, updateSkill, deleteSkill, getCategories]
+  );
+}
+function useSubAgents(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listSubAgents, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listSubAgentsApi.call(void 0, optionsRef.current),
+    (data) => data.subAgents,
+    []
+  );
+  const { execute: getSubAgent, loading: getLoading, error: getError } = useApiAsync(
+    (subAgentId) => _chunkIUKM3T2Sjs.getSubAgentApi.call(void 0, subAgentId, optionsRef.current),
+    (data) => data.subAgent || null,
+    null
+  );
+  const { execute: createSubAgent, loading: createLoading, error: createError } = useApiAsync(
+    (subAgent) => _chunkIUKM3T2Sjs.createSubAgentApi.call(void 0, subAgent, optionsRef.current),
+    (data) => data.subAgent || null,
+    null
+  );
+  const { execute: updateSubAgent, loading: updateLoading, error: updateError } = useApiAsync(
+    (subAgentId, subAgent) => _chunkIUKM3T2Sjs.updateSubAgentApi.call(void 0, subAgentId, subAgent, optionsRef.current),
+    (data) => data.subAgent || null,
+    null
+  );
+  const { execute: deleteSubAgent, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (subAgentId) => _chunkIUKM3T2Sjs.deleteSubAgentApi.call(void 0, subAgentId, optionsRef.current),
+    () => true,
+    false
+  );
+  const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading;
+  const error = listError || getError || createError || updateError || deleteError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listSubAgents,
+      getSubAgent,
+      createSubAgent,
+      updateSubAgent,
+      deleteSubAgent
+    }),
+    [loading, error, listSubAgents, getSubAgent, createSubAgent, updateSubAgent, deleteSubAgent]
+  );
+}
+function useToolDefinitions(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listToolDefinitions, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listToolDefinitionsApi.call(void 0, optionsRef.current),
+    (data) => data.toolDefinitions,
+    []
+  );
+  const { execute: getToolDefinition, loading: getLoading, error: getError } = useApiAsync(
+    (toolDefId) => _chunkIUKM3T2Sjs.getToolDefinitionApi.call(void 0, toolDefId, optionsRef.current),
+    (data) => data.toolDefinition || null,
+    null
+  );
+  const { execute: getToolDefinitionsByIds, loading: getByIdsLoading, error: getByIdsError } = useApiAsync(
+    (ids) => _chunkIUKM3T2Sjs.getToolDefinitionsByIdsApi.call(void 0, ids, optionsRef.current),
+    (data) => data.toolDefinitions,
+    []
+  );
+  const { execute: createToolDefinition, loading: createLoading, error: createError } = useApiAsync(
+    (toolDefinition) => _chunkIUKM3T2Sjs.createToolDefinitionApi.call(void 0, toolDefinition, optionsRef.current),
+    (data) => data.toolDefinition || null,
+    null
+  );
+  const { execute: updateToolDefinition, loading: updateLoading, error: updateError } = useApiAsync(
+    (toolDefId, toolDefinition) => _chunkIUKM3T2Sjs.updateToolDefinitionApi.call(void 0, toolDefId, toolDefinition, optionsRef.current),
+    (data) => data.toolDefinition || null,
+    null
+  );
+  const { execute: deleteToolDefinition, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (toolDefId) => _chunkIUKM3T2Sjs.deleteToolDefinitionApi.call(void 0, toolDefId, optionsRef.current),
+    () => true,
+    false
+  );
+  const loading = listLoading || getLoading || getByIdsLoading || createLoading || updateLoading || deleteLoading;
+  const error = listError || getError || getByIdsError || createError || updateError || deleteError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listToolDefinitions,
+      getToolDefinition,
+      getToolDefinitionsByIds,
+      createToolDefinition,
+      updateToolDefinition,
+      deleteToolDefinition
+    }),
+    [loading, error, listToolDefinitions, getToolDefinition, getToolDefinitionsByIds, createToolDefinition, updateToolDefinition, deleteToolDefinition]
+  );
+}
+function useAgentJobs(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listAgentJobs, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listAgentJobsApi.call(void 0, optionsRef.current),
+    (data) => data.jobs,
+    []
+  );
+  const { execute: getAgentJob, loading: getLoading, error: getError } = useApiAsync(
+    (jobId) => _chunkIUKM3T2Sjs.getAgentJobApi.call(void 0, jobId, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const { execute: createAgentJob, loading: createLoading, error: createError } = useApiAsync(
+    (job) => _chunkIUKM3T2Sjs.createAgentJobApi.call(void 0, job, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const { execute: updateAgentJob, loading: updateLoading, error: updateError } = useApiAsync(
+    (jobId, job) => _chunkIUKM3T2Sjs.updateAgentJobApi.call(void 0, jobId, job, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const { execute: deleteAgentJob, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (jobId) => _chunkIUKM3T2Sjs.deleteAgentJobApi.call(void 0, jobId, optionsRef.current),
+    () => true,
+    false
+  );
+  const { execute: pauseAgentJob, loading: pauseLoading, error: pauseError } = useApiAsync(
+    (jobId) => _chunkIUKM3T2Sjs.pauseAgentJobApi.call(void 0, jobId, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const { execute: resumeAgentJob, loading: resumeLoading, error: resumeError } = useApiAsync(
+    (jobId) => _chunkIUKM3T2Sjs.resumeAgentJobApi.call(void 0, jobId, optionsRef.current),
+    (data) => data.job || null,
+    null
+  );
+  const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading || pauseLoading || resumeLoading;
+  const error = listError || getError || createError || updateError || deleteError || pauseError || resumeError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listAgentJobs,
+      getAgentJob,
+      createAgentJob,
+      updateAgentJob,
+      deleteAgentJob,
+      pauseAgentJob,
+      resumeAgentJob
+    }),
+    [loading, error, listAgentJobs, getAgentJob, createAgentJob, updateAgentJob, deleteAgentJob, pauseAgentJob, resumeAgentJob]
+  );
+}
+function useWidgets(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listWidgets, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listWidgetsApi.call(void 0, optionsRef.current.agentId, optionsRef.current),
+    (data) => data.widgets,
+    []
+  );
+  const { execute: getWidget, loading: getLoading, error: getError } = useApiAsync(
+    (widgetId) => _chunkIUKM3T2Sjs.getWidgetApi.call(void 0, widgetId, optionsRef.current),
+    (data) => data.widget || null,
+    null
+  );
+  const { execute: getDefaultWidget, loading: defaultLoading, error: defaultError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.getDefaultWidgetApi.call(void 0, optionsRef.current.agentId, optionsRef.current),
+    (data) => data.widget || null,
+    null
+  );
+  const { execute: createWidget, loading: createLoading, error: createError } = useApiAsync(
+    (widget) => _chunkIUKM3T2Sjs.createWidgetApi.call(void 0, optionsRef.current.agentId, widget, optionsRef.current),
+    (data) => data.widget || null,
+    null
+  );
+  const { execute: updateWidget, loading: updateLoading, error: updateError } = useApiAsync(
+    (widgetId, widget) => _chunkIUKM3T2Sjs.updateWidgetApi.call(void 0, widgetId, widget, optionsRef.current),
+    (data) => data.widget || null,
+    null
+  );
+  const { execute: deleteWidget, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (widgetId) => _chunkIUKM3T2Sjs.deleteWidgetApi.call(void 0, widgetId, optionsRef.current),
+    () => true,
+    false
+  );
+  const { execute: setDefaultWidget, loading: setDefaultLoading, error: setDefaultError } = useApiAsync(
+    (widgetId) => _chunkIUKM3T2Sjs.setDefaultWidgetApi.call(void 0, widgetId, optionsRef.current.agentId, optionsRef.current),
+    () => true,
+    false
+  );
+  const loading = listLoading || getLoading || defaultLoading || createLoading || updateLoading || deleteLoading || setDefaultLoading;
+  const error = listError || getError || defaultError || createError || updateError || deleteError || setDefaultError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listWidgets,
+      getWidget,
+      getDefaultWidget,
+      createWidget,
+      updateWidget,
+      deleteWidget,
+      setDefaultWidget
+    }),
+    [loading, error, listWidgets, getWidget, getDefaultWidget, createWidget, updateWidget, deleteWidget, setDefaultWidget]
+  );
+}
+function useSkillUserConfig(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getSkillUserConfig, loading: getLoading, error: getError } = useApiAsync(
+    (skillId, agentId) => _chunkIUKM3T2Sjs.getSkillUserConfigApi.call(void 0, skillId, { ...optionsRef.current, agentId }),
+    (data) => data.userConfig || null,
+    null
+  );
+  const { execute: updateSkillUserConfig, loading: updateLoading, error: updateError } = useApiAsync(
+    (skillId, data) => _chunkIUKM3T2Sjs.updateSkillUserConfigApi.call(void 0, skillId, data, optionsRef.current),
+    (data) => data.userConfig || null,
+    null
+  );
+  const { execute: deleteSkillUserConfig, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (skillId, agentId) => _chunkIUKM3T2Sjs.deleteSkillUserConfigApi.call(void 0, skillId, { ...optionsRef.current, agentId }),
+    () => true,
+    false
+  );
+  const { execute: listSkillUserConfigs, loading: listLoading, error: listError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.listSkillUserConfigsApi.call(void 0, { ...optionsRef.current, ...params }),
+    (data) => data.userConfigs || [],
+    []
+  );
+  const { execute: resolveSkillConfig, loading: resolveLoading, error: resolveError } = useApiAsync(
+    (skillId, agentId) => _chunkIUKM3T2Sjs.resolveSkillConfigApi.call(void 0, skillId, agentId, optionsRef.current),
+    (data) => data,
+    null
+  );
+  const loading = getLoading || updateLoading || deleteLoading || listLoading || resolveLoading;
+  const error = getError || updateError || deleteError || listError || resolveError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      getSkillUserConfig,
+      updateSkillUserConfig,
+      deleteSkillUserConfig,
+      listSkillUserConfigs,
+      resolveSkillConfig
+    }),
+    [loading, error, getSkillUserConfig, updateSkillUserConfig, deleteSkillUserConfig, listSkillUserConfigs, resolveSkillConfig]
+  );
+}
+function useAnalytics(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: getAgentChatsAnalytics, loading: chatsLoading, error: chatsError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.getAgentChatsAnalyticsApi.call(void 0, params, optionsRef.current),
+    (data) => data.data,
+    []
+  );
+  const { execute: getAgentCSATAnalytics, loading: csatLoading, error: csatError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.getAgentCSATAnalyticsApi.call(void 0, params, optionsRef.current),
+    (data) => data.data,
+    []
+  );
+  const { execute: getAgentListAnalytics, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.getAgentListAnalyticsApi.call(void 0, optionsRef.current),
+    (data) => data.data,
+    []
+  );
+  const { execute: getTaskOutcomes, loading: taskLoading, error: taskError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.getTaskOutcomesApi.call(void 0, params, optionsRef.current),
+    (data) => data.data,
+    []
+  );
+  const loading = chatsLoading || csatLoading || listLoading || taskLoading;
+  const error = chatsError || csatError || listError || taskError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      getAgentChatsAnalytics,
+      getAgentCSATAnalytics,
+      getAgentListAnalytics,
+      getTaskOutcomes
+    }),
+    [loading, error, getAgentChatsAnalytics, getAgentCSATAnalytics, getAgentListAnalytics, getTaskOutcomes]
+  );
+}
+function useIntegrations(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listIntegrations, loading: listLoading, error: listError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.listIntegrationsApi.call(void 0, optionsRef.current),
+    (data) => data.integrations,
+    []
+  );
+  const { execute: getIntegration, loading: getLoading, error: getError } = useApiAsync(
+    (provider, integrationType) => _chunkIUKM3T2Sjs.getIntegrationApi.call(void 0, provider, integrationType, optionsRef.current),
+    (data) => data.integration || null,
+    null
+  );
+  const { execute: connectIntegration, loading: connectLoading, error: connectError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.connectIntegrationApi.call(void 0, params, optionsRef.current),
+    (data) => ({ authUrl: data.auth_url, state: data.state }),
+    null
+  );
+  const { execute: disconnectIntegration, loading: disconnectLoading, error: disconnectError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.disconnectIntegrationApi.call(void 0, params, optionsRef.current),
+    () => true,
+    false
+  );
+  const { execute: refreshIntegration, loading: refreshLoading, error: refreshError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.refreshIntegrationApi.call(void 0, params, optionsRef.current),
+    (data) => data.integration || null,
+    null
+  );
+  const { execute: updateTriage, loading: updateTriageLoading, error: updateTriageError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.updateIntegrationTriageApi.call(void 0, params, optionsRef.current),
+    (data) => data.integration || null,
+    null
+  );
+  const { execute: runEmailTriage, loading: runTriageLoading, error: runTriageError } = useApiAsync(
+    () => _chunkIUKM3T2Sjs.runEmailTriageApi.call(void 0, optionsRef.current),
+    (data) => ({ success: data.success, emailsFound: data.emails_found, instancesCreated: data.instances_created }),
+    null
+  );
+  const loading = listLoading || getLoading || connectLoading || disconnectLoading || refreshLoading || updateTriageLoading || runTriageLoading;
+  const error = listError || getError || connectError || disconnectError || refreshError || updateTriageError || runTriageError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listIntegrations,
+      getIntegration,
+      connectIntegration,
+      disconnectIntegration,
+      refreshIntegration,
+      updateTriage,
+      runEmailTriage
+    }),
+    [loading, error, listIntegrations, getIntegration, connectIntegration, disconnectIntegration, refreshIntegration, updateTriage, runEmailTriage]
+  );
+}
+function useSandbox(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: createSandbox, loading: createLoading, error: createError } = useApiAsync(
+    (request) => _chunkIUKM3T2Sjs.createSandboxApi.call(void 0, request, optionsRef.current),
+    (data) => ({ id: data.id, url: data.url, sandbox: data.sandbox }),
+    null
+  );
+  const { execute: getSandbox, loading: getLoading, error: getError } = useApiAsync(
+    (sandboxId) => _chunkIUKM3T2Sjs.getSandboxApi.call(void 0, sandboxId, optionsRef.current),
+    (data) => data.sandbox || null,
+    null
+  );
+  const { execute: updateSandbox, loading: updateLoading, error: updateError } = useApiAsync(
+    (sandboxId, request) => _chunkIUKM3T2Sjs.updateSandboxApi.call(void 0, sandboxId, request, optionsRef.current),
+    (data) => ({ id: data.id, url: data.url, sandbox: data.sandbox }),
+    null
+  );
+  const { execute: listSandboxes, loading: listLoading, error: listError } = useApiAsync(
+    (limit) => _chunkIUKM3T2Sjs.listSandboxesApi.call(void 0, { ...optionsRef.current, limit }),
+    (data) => ({ sandboxes: data.sandboxes, total: data.total }),
+    { sandboxes: [], total: 0 }
+  );
+  const { execute: deleteSandbox, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (sandboxId) => _chunkIUKM3T2Sjs.deleteSandboxApi.call(void 0, sandboxId, optionsRef.current),
+    (data) => data.success,
+    false
+  );
+  const loading = createLoading || getLoading || updateLoading || listLoading || deleteLoading;
+  const error = createError || getError || updateError || listError || deleteError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      createSandbox,
+      getSandbox,
+      updateSandbox,
+      listSandboxes,
+      deleteSandbox
+    }),
+    [loading, error, createSandbox, getSandbox, updateSandbox, listSandboxes, deleteSandbox]
+  );
+}
+function useSchedulerTasks(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listTasks, loading: listLoading, error: listError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.listSchedulerTasksApi.call(void 0, { ...optionsRef.current, ...params }),
+    (data) => data.tasks,
+    []
+  );
+  const { execute: createTask, loading: createLoading, error: createError } = useApiAsync(
+    (task) => _chunkIUKM3T2Sjs.createSchedulerTaskApi.call(void 0, task, optionsRef.current),
+    (data) => data.task || null,
+    null
+  );
+  const { execute: getTask, loading: getLoading, error: getError } = useApiAsync(
+    (taskId) => _chunkIUKM3T2Sjs.getSchedulerTaskApi.call(void 0, taskId, optionsRef.current),
+    (data) => data.task || null,
+    null
+  );
+  const { execute: updateTask, loading: updateLoading, error: updateError } = useApiAsync(
+    (taskId, task) => _chunkIUKM3T2Sjs.updateSchedulerTaskApi.call(void 0, taskId, task, optionsRef.current),
+    (data) => data.task || null,
+    null
+  );
+  const { execute: deleteTask, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (taskId) => _chunkIUKM3T2Sjs.deleteSchedulerTaskApi.call(void 0, taskId, optionsRef.current),
+    (data) => data.success,
+    false
+  );
+  const { execute: snoozeTask, loading: snoozeLoading, error: snoozeError } = useApiAsync(
+    (taskId, delay) => _chunkIUKM3T2Sjs.snoozeSchedulerTaskApi.call(void 0, taskId, delay, optionsRef.current),
+    (data) => data.task || null,
+    null
+  );
+  const { execute: completeTask, loading: completeLoading, error: completeError } = useApiAsync(
+    (taskId) => _chunkIUKM3T2Sjs.completeSchedulerTaskApi.call(void 0, taskId, optionsRef.current),
+    (data) => data.task || null,
+    null
+  );
+  const { execute: startTask, loading: startLoading, error: startError } = useApiAsync(
+    (taskId) => _chunkIUKM3T2Sjs.startSchedulerTaskApi.call(void 0, taskId, optionsRef.current),
+    (data) => data.task || null,
+    null
+  );
+  const loading = listLoading || createLoading || getLoading || updateLoading || deleteLoading || snoozeLoading || completeLoading || startLoading;
+  const error = listError || createError || getError || updateError || deleteError || snoozeError || completeError || startError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listTasks,
+      createTask,
+      getTask,
+      updateTask,
+      deleteTask,
+      snoozeTask,
+      completeTask,
+      startTask
+    }),
+    [loading, error, listTasks, createTask, getTask, updateTask, deleteTask, snoozeTask, completeTask, startTask]
+  );
+}
+function useSchedulerSchedules(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: listSchedules, loading: listLoading, error: listError } = useApiAsync(
+    (params) => _chunkIUKM3T2Sjs.listSchedulesApi.call(void 0, { ...optionsRef.current, ...params }),
+    (data) => data.schedules,
+    []
+  );
+  const { execute: createSchedule, loading: createLoading, error: createError } = useApiAsync(
+    (schedule) => _chunkIUKM3T2Sjs.createScheduleApi.call(void 0, schedule, optionsRef.current),
+    (data) => data.schedule || null,
+    null
+  );
+  const { execute: getSchedule, loading: getLoading, error: getError } = useApiAsync(
+    (scheduleId) => _chunkIUKM3T2Sjs.getScheduleApi.call(void 0, scheduleId, optionsRef.current),
+    (data) => data.schedule || null,
+    null
+  );
+  const { execute: updateSchedule, loading: updateLoading, error: updateError } = useApiAsync(
+    (scheduleId, schedule) => _chunkIUKM3T2Sjs.updateScheduleApi.call(void 0, scheduleId, schedule, optionsRef.current),
+    (data) => data.schedule || null,
+    null
+  );
+  const { execute: deleteSchedule, loading: deleteLoading, error: deleteError } = useApiAsync(
+    (scheduleId) => _chunkIUKM3T2Sjs.deleteScheduleApi.call(void 0, scheduleId, optionsRef.current),
+    (data) => data.success,
+    false
+  );
+  const { execute: pauseSchedule, loading: pauseLoading, error: pauseError } = useApiAsync(
+    (scheduleId) => _chunkIUKM3T2Sjs.pauseScheduleApi.call(void 0, scheduleId, optionsRef.current),
+    (data) => data.schedule || null,
+    null
+  );
+  const { execute: resumeSchedule, loading: resumeLoading, error: resumeError } = useApiAsync(
+    (scheduleId) => _chunkIUKM3T2Sjs.resumeScheduleApi.call(void 0, scheduleId, optionsRef.current),
+    (data) => data.schedule || null,
+    null
+  );
+  const { execute: runSchedule, loading: runLoading, error: runError } = useApiAsync(
+    (scheduleId) => _chunkIUKM3T2Sjs.runScheduleApi.call(void 0, scheduleId, optionsRef.current),
+    (data) => data.schedule || null,
+    null
+  );
+  const loading = listLoading || createLoading || getLoading || updateLoading || deleteLoading || pauseLoading || resumeLoading || runLoading;
+  const error = listError || createError || getError || updateError || deleteError || pauseError || resumeError || runError;
+  return _react.useMemo.call(void 0, 
+    () => ({
+      loading,
+      error,
+      listSchedules,
+      createSchedule,
+      getSchedule,
+      updateSchedule,
+      deleteSchedule,
+      pauseSchedule,
+      resumeSchedule,
+      runSchedule
+    }),
+    [loading, error, listSchedules, createSchedule, getSchedule, updateSchedule, deleteSchedule, pauseSchedule, resumeSchedule, runSchedule]
+  );
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.useAsync = useAsync; exports.useApiAsync = useApiAsync; exports.useOptionsRef = useOptionsRef; exports.useAgents = useAgents; exports.useSkills = useSkills; exports.useSubAgents = useSubAgents; exports.useToolDefinitions = useToolDefinitions; exports.useAgentJobs = useAgentJobs; exports.useWidgets = useWidgets; exports.useSkillUserConfig = useSkillUserConfig; exports.useAnalytics = useAnalytics; exports.useIntegrations = useIntegrations; exports.useSandbox = useSandbox; exports.useSchedulerTasks = useSchedulerTasks; exports.useSchedulerSchedules = useSchedulerSchedules;
+//# sourceMappingURL=chunk-RGVWAFZP.js.map