@elqnt/agents 3.2.0 → 3.3.0

package/dist/{chunk-V5GHDXSW.mjs → chunk-MNFZXJ2Y.mjs}

@@ -1,5 +1,6 @@
 "use client";
 import {
+  checkBackgroundAgentStatusApi,
   completeSchedulerTaskApi,
   connectIntegrationApi,
   createAgentApi,
@@ -22,6 +23,7 @@ import {
   deleteToolDefinitionApi,
   deleteWidgetApi,
   disconnectIntegrationApi,
+  exportAgentApi,
   getAgentApi,
   getAgentCSATAnalyticsApi,
   getAgentChatsAnalyticsApi,
@@ -41,6 +43,7 @@ import {
   getToolDefinitionApi,
   getToolDefinitionsByIdsApi,
   getWidgetApi,
+  importAgentApi,
   listAgentJobsApi,
   listAgentsApi,
   listAgentsSummaryApi,
@@ -64,6 +67,8 @@ import {
   setDefaultWidgetApi,
   snoozeSchedulerTaskApi,
   startSchedulerTaskApi,
+  structuredOutputApi,
+  triggerBackgroundAgentApi,
   updateAgentApi,
   updateAgentJobApi,
   updateIntegrationTriageApi,
@@ -75,87 +80,26 @@ import {
   updateSubAgentApi,
   updateToolDefinitionApi,
   updateWidgetApi
-} from "./chunk-FR422IHO.mjs";
+} from "./chunk-BT33DRUI.mjs";
+import {
+  createBGAgentTransport
+} from "./chunk-3EHE4O57.mjs";
 
-// hooks/index.ts
+// hooks/use-agents.ts
 import { useMemo } from "react";
-
-// hooks/use-async.ts
-import { useState, useCallback, useRef } from "react";
-function useAsync(asyncFn, options) {
-  const [error, setError] = useState(null);
-  const requestCountRef = useRef(0);
-  const [loading, setLoading] = useState(false);
-  const execute = useCallback(
-    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);
-        options?.onError?.(message);
-        throw err;
-      } finally {
-        requestCountRef.current -= 1;
-        if (requestCountRef.current === 0) {
-          setLoading(false);
-        }
-      }
-    },
-    [asyncFn, options]
-  );
-  const clearError = useCallback(() => setError(null), []);
-  return { execute, loading, error, clearError };
-}
-function useApiAsync(asyncFn, extractor, defaultValue, options) {
-  const [error, setError] = useState(null);
-  const requestCountRef = useRef(0);
-  const [loading, setLoading] = useState(false);
-  const execute = useCallback(
-    async (...args) => {
-      requestCountRef.current += 1;
-      setLoading(true);
-      setError(null);
-      try {
-        const response = await asyncFn(...args);
-        if (response.error) {
-          setError(response.error);
-          options?.onError?.(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);
-        options?.onError?.(message);
-        return defaultValue;
-      } finally {
-        requestCountRef.current -= 1;
-        if (requestCountRef.current === 0) {
-          setLoading(false);
-        }
-      }
-    },
-    [asyncFn, extractor, defaultValue, options]
-  );
-  const clearError = useCallback(() => setError(null), []);
-  return { execute, loading, error, clearError };
-}
+import { useApiAsync } from "@elqnt/api-client/hooks";
 
 // hooks/use-options-ref.ts
-import { useRef as useRef2, useEffect } from "react";
+import { useRef, useEffect } from "react";
 function useOptionsRef(options) {
-  const optionsRef = useRef2(options);
+  const optionsRef = useRef(options);
   useEffect(() => {
     optionsRef.current = options;
   }, [options]);
   return optionsRef;
 }
 
-// hooks/index.ts
+// hooks/use-agents.ts
 function useAgents(options) {
   const optionsRef = useOptionsRef(options);
   const { execute: listAgents, loading: listLoading, error: listError } = useApiAsync(
@@ -193,8 +137,25 @@ function useAgents(options) {
     (data) => data.agent || null,
     null
   );
-  const loading = listLoading || listSummaryLoading || getLoading || createLoading || updateLoading || deleteLoading || defaultLoading;
-  const error = listError || listSummaryError || getError || createError || updateError || deleteError || defaultError;
+  const exportAgent = async (agentId) => {
+    const agent = await exportAgentApi(agentId, optionsRef.current);
+    const json = JSON.stringify(agent, null, 2);
+    const blob = new Blob([json], { type: "application/json" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${agent.name || "agent"}.agent.json`;
+    a.click();
+    URL.revokeObjectURL(url);
+    return agent;
+  };
+  const { execute: importAgent, loading: importLoading, error: importError } = useApiAsync(
+    (agent) => importAgentApi(agent, optionsRef.current),
+    (data) => data.agent || null,
+    null
+  );
+  const loading = listLoading || listSummaryLoading || getLoading || createLoading || updateLoading || deleteLoading || defaultLoading || importLoading;
+  const error = listError || listSummaryError || getError || createError || updateError || deleteError || defaultError || importError;
   return useMemo(
     () => ({
       loading,
@@ -205,46 +166,52 @@ function useAgents(options) {
       createAgent,
       updateAgent,
       deleteAgent,
-      getDefaultAgent
+      getDefaultAgent,
+      exportAgent,
+      importAgent
     }),
-    [loading, error, listAgents, listAgentSummaries, getAgent, createAgent, updateAgent, deleteAgent, getDefaultAgent]
+    [loading, error, listAgents, listAgentSummaries, getAgent, createAgent, updateAgent, deleteAgent, getDefaultAgent, exportAgent, importAgent]
   );
 }
+
+// hooks/use-skills.ts
+import { useMemo as useMemo2 } from "react";
+import { useApiAsync as useApiAsync2 } from "@elqnt/api-client/hooks";
 function useSkills(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listSkills, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listSkills, loading: listLoading, error: listError } = useApiAsync2(
     () => listSkillsApi(optionsRef.current),
     (data) => data.skills,
     []
   );
-  const { execute: getSkill, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getSkill, loading: getLoading, error: getError } = useApiAsync2(
     (skillId) => getSkillApi(skillId, optionsRef.current),
     (data) => data.skill || null,
     null
   );
-  const { execute: createSkill, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createSkill, loading: createLoading, error: createError } = useApiAsync2(
     (skill) => createSkillApi(skill, optionsRef.current),
     (data) => data.skill || null,
     null
   );
-  const { execute: updateSkill, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateSkill, loading: updateLoading, error: updateError } = useApiAsync2(
     (skillId, skill) => updateSkillApi(skillId, skill, optionsRef.current),
     (data) => data.skill || null,
     null
   );
-  const { execute: deleteSkill, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteSkill, loading: deleteLoading, error: deleteError } = useApiAsync2(
     (skillId) => deleteSkillApi(skillId, optionsRef.current),
     () => true,
     false
   );
-  const { execute: getCategories, loading: categoriesLoading, error: categoriesError } = useApiAsync(
+  const { execute: getCategories, loading: categoriesLoading, error: categoriesError } = useApiAsync2(
     () => getSkillCategoriesApi(optionsRef.current),
     (data) => data.categories,
     []
   );
   const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading || categoriesLoading;
   const error = listError || getError || createError || updateError || deleteError || categoriesError;
-  return useMemo(
+  return useMemo2(
     () => ({
       loading,
       error,
@@ -258,36 +225,40 @@ function useSkills(options) {
     [loading, error, listSkills, getSkill, createSkill, updateSkill, deleteSkill, getCategories]
   );
 }
+
+// hooks/use-sub-agents.ts
+import { useMemo as useMemo3 } from "react";
+import { useApiAsync as useApiAsync3 } from "@elqnt/api-client/hooks";
 function useSubAgents(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listSubAgents, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listSubAgents, loading: listLoading, error: listError } = useApiAsync3(
     () => listSubAgentsApi(optionsRef.current),
     (data) => data.subAgents,
     []
   );
-  const { execute: getSubAgent, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getSubAgent, loading: getLoading, error: getError } = useApiAsync3(
     (subAgentId) => getSubAgentApi(subAgentId, optionsRef.current),
     (data) => data.subAgent || null,
     null
   );
-  const { execute: createSubAgent, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createSubAgent, loading: createLoading, error: createError } = useApiAsync3(
     (subAgent) => createSubAgentApi(subAgent, optionsRef.current),
     (data) => data.subAgent || null,
     null
   );
-  const { execute: updateSubAgent, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateSubAgent, loading: updateLoading, error: updateError } = useApiAsync3(
     (subAgentId, subAgent) => updateSubAgentApi(subAgentId, subAgent, optionsRef.current),
     (data) => data.subAgent || null,
     null
   );
-  const { execute: deleteSubAgent, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteSubAgent, loading: deleteLoading, error: deleteError } = useApiAsync3(
     (subAgentId) => deleteSubAgentApi(subAgentId, optionsRef.current),
     () => true,
     false
   );
   const loading = listLoading || getLoading || createLoading || updateLoading || deleteLoading;
   const error = listError || getError || createError || updateError || deleteError;
-  return useMemo(
+  return useMemo3(
     () => ({
       loading,
       error,
@@ -300,41 +271,45 @@ function useSubAgents(options) {
     [loading, error, listSubAgents, getSubAgent, createSubAgent, updateSubAgent, deleteSubAgent]
   );
 }
+
+// hooks/use-tool-definitions.ts
+import { useMemo as useMemo4 } from "react";
+import { useApiAsync as useApiAsync4 } from "@elqnt/api-client/hooks";
 function useToolDefinitions(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listToolDefinitions, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listToolDefinitions, loading: listLoading, error: listError } = useApiAsync4(
     () => listToolDefinitionsApi(optionsRef.current),
     (data) => data.toolDefinitions,
     []
   );
-  const { execute: getToolDefinition, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getToolDefinition, loading: getLoading, error: getError } = useApiAsync4(
     (toolDefId) => getToolDefinitionApi(toolDefId, optionsRef.current),
     (data) => data.toolDefinition || null,
     null
   );
-  const { execute: getToolDefinitionsByIds, loading: getByIdsLoading, error: getByIdsError } = useApiAsync(
+  const { execute: getToolDefinitionsByIds, loading: getByIdsLoading, error: getByIdsError } = useApiAsync4(
     (ids) => getToolDefinitionsByIdsApi(ids, optionsRef.current),
     (data) => data.toolDefinitions,
     []
   );
-  const { execute: createToolDefinition, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createToolDefinition, loading: createLoading, error: createError } = useApiAsync4(
     (toolDefinition) => createToolDefinitionApi(toolDefinition, optionsRef.current),
     (data) => data.toolDefinition || null,
     null
   );
-  const { execute: updateToolDefinition, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateToolDefinition, loading: updateLoading, error: updateError } = useApiAsync4(
     (toolDefId, toolDefinition) => updateToolDefinitionApi(toolDefId, toolDefinition, optionsRef.current),
     (data) => data.toolDefinition || null,
     null
   );
-  const { execute: deleteToolDefinition, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteToolDefinition, loading: deleteLoading, error: deleteError } = useApiAsync4(
     (toolDefId) => deleteToolDefinitionApi(toolDefId, optionsRef.current),
     () => true,
     false
   );
   const loading = listLoading || getLoading || getByIdsLoading || createLoading || updateLoading || deleteLoading;
   const error = listError || getError || getByIdsError || createError || updateError || deleteError;
-  return useMemo(
+  return useMemo4(
     () => ({
       loading,
       error,
@@ -348,46 +323,50 @@ function useToolDefinitions(options) {
     [loading, error, listToolDefinitions, getToolDefinition, getToolDefinitionsByIds, createToolDefinition, updateToolDefinition, deleteToolDefinition]
   );
 }
+
+// hooks/use-agent-jobs.ts
+import { useMemo as useMemo5 } from "react";
+import { useApiAsync as useApiAsync5 } from "@elqnt/api-client/hooks";
 function useAgentJobs(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listAgentJobs, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listAgentJobs, loading: listLoading, error: listError } = useApiAsync5(
     () => listAgentJobsApi(optionsRef.current),
     (data) => data.jobs,
     []
   );
-  const { execute: getAgentJob, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getAgentJob, loading: getLoading, error: getError } = useApiAsync5(
     (jobId) => getAgentJobApi(jobId, optionsRef.current),
     (data) => data.job || null,
     null
   );
-  const { execute: createAgentJob, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createAgentJob, loading: createLoading, error: createError } = useApiAsync5(
     (job) => createAgentJobApi(job, optionsRef.current),
     (data) => data.job || null,
     null
   );
-  const { execute: updateAgentJob, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateAgentJob, loading: updateLoading, error: updateError } = useApiAsync5(
     (jobId, job) => updateAgentJobApi(jobId, job, optionsRef.current),
     (data) => data.job || null,
     null
   );
-  const { execute: deleteAgentJob, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteAgentJob, loading: deleteLoading, error: deleteError } = useApiAsync5(
     (jobId) => deleteAgentJobApi(jobId, optionsRef.current),
     () => true,
     false
   );
-  const { execute: pauseAgentJob, loading: pauseLoading, error: pauseError } = useApiAsync(
+  const { execute: pauseAgentJob, loading: pauseLoading, error: pauseError } = useApiAsync5(
     (jobId) => pauseAgentJobApi(jobId, optionsRef.current),
     (data) => data.job || null,
     null
   );
-  const { execute: resumeAgentJob, loading: resumeLoading, error: resumeError } = useApiAsync(
+  const { execute: resumeAgentJob, loading: resumeLoading, error: resumeError } = useApiAsync5(
     (jobId) => resumeAgentJobApi(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 useMemo(
+  return useMemo5(
     () => ({
       loading,
       error,
@@ -402,46 +381,50 @@ function useAgentJobs(options) {
     [loading, error, listAgentJobs, getAgentJob, createAgentJob, updateAgentJob, deleteAgentJob, pauseAgentJob, resumeAgentJob]
   );
 }
+
+// hooks/use-widgets.ts
+import { useMemo as useMemo6 } from "react";
+import { useApiAsync as useApiAsync6 } from "@elqnt/api-client/hooks";
 function useWidgets(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listWidgets, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listWidgets, loading: listLoading, error: listError } = useApiAsync6(
     () => listWidgetsApi(optionsRef.current.agentId, optionsRef.current),
     (data) => data.widgets,
     []
   );
-  const { execute: getWidget, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getWidget, loading: getLoading, error: getError } = useApiAsync6(
     (widgetId) => getWidgetApi(widgetId, optionsRef.current),
     (data) => data.widget || null,
     null
   );
-  const { execute: getDefaultWidget, loading: defaultLoading, error: defaultError } = useApiAsync(
+  const { execute: getDefaultWidget, loading: defaultLoading, error: defaultError } = useApiAsync6(
     () => getDefaultWidgetApi(optionsRef.current.agentId, optionsRef.current),
     (data) => data.widget || null,
     null
   );
-  const { execute: createWidget, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createWidget, loading: createLoading, error: createError } = useApiAsync6(
     (widget) => createWidgetApi(optionsRef.current.agentId, widget, optionsRef.current),
     (data) => data.widget || null,
     null
   );
-  const { execute: updateWidget, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateWidget, loading: updateLoading, error: updateError } = useApiAsync6(
     (widgetId, widget) => updateWidgetApi(widgetId, widget, optionsRef.current),
     (data) => data.widget || null,
     null
   );
-  const { execute: deleteWidget, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteWidget, loading: deleteLoading, error: deleteError } = useApiAsync6(
     (widgetId) => deleteWidgetApi(widgetId, optionsRef.current),
     () => true,
     false
   );
-  const { execute: setDefaultWidget, loading: setDefaultLoading, error: setDefaultError } = useApiAsync(
+  const { execute: setDefaultWidget, loading: setDefaultLoading, error: setDefaultError } = useApiAsync6(
     (widgetId) => setDefaultWidgetApi(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 useMemo(
+  return useMemo6(
     () => ({
       loading,
       error,
@@ -456,36 +439,40 @@ function useWidgets(options) {
     [loading, error, listWidgets, getWidget, getDefaultWidget, createWidget, updateWidget, deleteWidget, setDefaultWidget]
   );
 }
+
+// hooks/use-skill-user-config.ts
+import { useMemo as useMemo7 } from "react";
+import { useApiAsync as useApiAsync7 } from "@elqnt/api-client/hooks";
 function useSkillUserConfig(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: getSkillUserConfig, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getSkillUserConfig, loading: getLoading, error: getError } = useApiAsync7(
     (skillId, agentId) => getSkillUserConfigApi(skillId, { ...optionsRef.current, agentId }),
     (data) => data.userConfig || null,
     null
   );
-  const { execute: updateSkillUserConfig, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateSkillUserConfig, loading: updateLoading, error: updateError } = useApiAsync7(
     (skillId, data) => updateSkillUserConfigApi(skillId, data, optionsRef.current),
     (data) => data.userConfig || null,
     null
   );
-  const { execute: deleteSkillUserConfig, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteSkillUserConfig, loading: deleteLoading, error: deleteError } = useApiAsync7(
     (skillId, agentId) => deleteSkillUserConfigApi(skillId, { ...optionsRef.current, agentId }),
     () => true,
     false
   );
-  const { execute: listSkillUserConfigs, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listSkillUserConfigs, loading: listLoading, error: listError } = useApiAsync7(
     (params) => listSkillUserConfigsApi({ ...optionsRef.current, ...params }),
     (data) => data.userConfigs || [],
     []
   );
-  const { execute: resolveSkillConfig, loading: resolveLoading, error: resolveError } = useApiAsync(
+  const { execute: resolveSkillConfig, loading: resolveLoading, error: resolveError } = useApiAsync7(
     (skillId, agentId) => resolveSkillConfigApi(skillId, agentId, optionsRef.current),
     (data) => data,
     null
   );
   const loading = getLoading || updateLoading || deleteLoading || listLoading || resolveLoading;
   const error = getError || updateError || deleteError || listError || resolveError;
-  return useMemo(
+  return useMemo7(
     () => ({
       loading,
       error,
@@ -498,31 +485,35 @@ function useSkillUserConfig(options) {
     [loading, error, getSkillUserConfig, updateSkillUserConfig, deleteSkillUserConfig, listSkillUserConfigs, resolveSkillConfig]
   );
 }
+
+// hooks/use-analytics.ts
+import { useMemo as useMemo8 } from "react";
+import { useApiAsync as useApiAsync8 } from "@elqnt/api-client/hooks";
 function useAnalytics(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: getAgentChatsAnalytics, loading: chatsLoading, error: chatsError } = useApiAsync(
+  const { execute: getAgentChatsAnalytics, loading: chatsLoading, error: chatsError } = useApiAsync8(
     (params) => getAgentChatsAnalyticsApi(params, optionsRef.current),
     (data) => data.data,
     []
   );
-  const { execute: getAgentCSATAnalytics, loading: csatLoading, error: csatError } = useApiAsync(
+  const { execute: getAgentCSATAnalytics, loading: csatLoading, error: csatError } = useApiAsync8(
     (params) => getAgentCSATAnalyticsApi(params, optionsRef.current),
     (data) => data.data,
     []
   );
-  const { execute: getAgentListAnalytics, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: getAgentListAnalytics, loading: listLoading, error: listError } = useApiAsync8(
     () => getAgentListAnalyticsApi(optionsRef.current),
     (data) => data.data,
     []
   );
-  const { execute: getTaskOutcomes, loading: taskLoading, error: taskError } = useApiAsync(
+  const { execute: getTaskOutcomes, loading: taskLoading, error: taskError } = useApiAsync8(
     (params) => getTaskOutcomesApi(params, optionsRef.current),
     (data) => data.data,
     []
   );
   const loading = chatsLoading || csatLoading || listLoading || taskLoading;
   const error = chatsError || csatError || listError || taskError;
-  return useMemo(
+  return useMemo8(
     () => ({
       loading,
       error,
@@ -534,46 +525,50 @@ function useAnalytics(options) {
     [loading, error, getAgentChatsAnalytics, getAgentCSATAnalytics, getAgentListAnalytics, getTaskOutcomes]
   );
 }
+
+// hooks/use-integrations.ts
+import { useMemo as useMemo9 } from "react";
+import { useApiAsync as useApiAsync9 } from "@elqnt/api-client/hooks";
 function useIntegrations(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listIntegrations, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listIntegrations, loading: listLoading, error: listError } = useApiAsync9(
     () => listIntegrationsApi(optionsRef.current),
     (data) => data.integrations,
     []
   );
-  const { execute: getIntegration, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getIntegration, loading: getLoading, error: getError } = useApiAsync9(
     (provider, integrationType) => getIntegrationApi(provider, integrationType, optionsRef.current),
     (data) => data.integration || null,
     null
   );
-  const { execute: connectIntegration, loading: connectLoading, error: connectError } = useApiAsync(
+  const { execute: connectIntegration, loading: connectLoading, error: connectError } = useApiAsync9(
     (params) => connectIntegrationApi(params, optionsRef.current),
     (data) => ({ authUrl: data.auth_url, state: data.state }),
     null
   );
-  const { execute: disconnectIntegration, loading: disconnectLoading, error: disconnectError } = useApiAsync(
+  const { execute: disconnectIntegration, loading: disconnectLoading, error: disconnectError } = useApiAsync9(
     (params) => disconnectIntegrationApi(params, optionsRef.current),
     () => true,
     false
   );
-  const { execute: refreshIntegration, loading: refreshLoading, error: refreshError } = useApiAsync(
+  const { execute: refreshIntegration, loading: refreshLoading, error: refreshError } = useApiAsync9(
     (params) => refreshIntegrationApi(params, optionsRef.current),
     (data) => data.integration || null,
     null
   );
-  const { execute: updateTriage, loading: updateTriageLoading, error: updateTriageError } = useApiAsync(
+  const { execute: updateTriage, loading: updateTriageLoading, error: updateTriageError } = useApiAsync9(
     (params) => updateIntegrationTriageApi(params, optionsRef.current),
     (data) => data.integration || null,
     null
   );
-  const { execute: runEmailTriage, loading: runTriageLoading, error: runTriageError } = useApiAsync(
+  const { execute: runEmailTriage, loading: runTriageLoading, error: runTriageError } = useApiAsync9(
     () => runEmailTriageApi(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 useMemo(
+  return useMemo9(
     () => ({
       loading,
       error,
@@ -588,36 +583,40 @@ function useIntegrations(options) {
     [loading, error, listIntegrations, getIntegration, connectIntegration, disconnectIntegration, refreshIntegration, updateTriage, runEmailTriage]
   );
 }
+
+// hooks/use-sandbox.ts
+import { useMemo as useMemo10 } from "react";
+import { useApiAsync as useApiAsync10 } from "@elqnt/api-client/hooks";
 function useSandbox(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: createSandbox, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createSandbox, loading: createLoading, error: createError } = useApiAsync10(
     (request) => createSandboxApi(request, optionsRef.current),
     (data) => ({ id: data.id, url: data.url, sandbox: data.sandbox }),
     null
   );
-  const { execute: getSandbox, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getSandbox, loading: getLoading, error: getError } = useApiAsync10(
     (sandboxId) => getSandboxApi(sandboxId, optionsRef.current),
     (data) => data.sandbox || null,
     null
   );
-  const { execute: updateSandbox, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateSandbox, loading: updateLoading, error: updateError } = useApiAsync10(
     (sandboxId, request) => updateSandboxApi(sandboxId, request, optionsRef.current),
     (data) => ({ id: data.id, url: data.url, sandbox: data.sandbox }),
     null
   );
-  const { execute: listSandboxes, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listSandboxes, loading: listLoading, error: listError } = useApiAsync10(
     (limit) => listSandboxesApi({ ...optionsRef.current, limit }),
     (data) => ({ sandboxes: data.sandboxes, total: data.total }),
     { sandboxes: [], total: 0 }
   );
-  const { execute: deleteSandbox, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteSandbox, loading: deleteLoading, error: deleteError } = useApiAsync10(
     (sandboxId) => deleteSandboxApi(sandboxId, optionsRef.current),
     (data) => data.success,
     false
   );
   const loading = createLoading || getLoading || updateLoading || listLoading || deleteLoading;
   const error = createError || getError || updateError || listError || deleteError;
-  return useMemo(
+  return useMemo10(
     () => ({
       loading,
       error,
@@ -630,51 +629,71 @@ function useSandbox(options) {
     [loading, error, createSandbox, getSandbox, updateSandbox, listSandboxes, deleteSandbox]
   );
 }
+
+// hooks/use-structured-output.ts
+import { useMemo as useMemo11 } from "react";
+import { useApiAsync as useApiAsync11 } from "@elqnt/api-client/hooks";
+function useStructuredOutput(options) {
+  const optionsRef = useOptionsRef(options);
+  const { execute: run, loading, error, clearError } = useApiAsync11(
+    (request) => structuredOutputApi(request, optionsRef.current),
+    (resp) => resp,
+    null
+  );
+  return useMemo11(
+    () => ({ run, loading, error, clearError }),
+    [run, loading, error, clearError]
+  );
+}
+
+// hooks/use-scheduler-tasks.ts
+import { useMemo as useMemo12 } from "react";
+import { useApiAsync as useApiAsync12 } from "@elqnt/api-client/hooks";
 function useSchedulerTasks(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listTasks, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listTasks, loading: listLoading, error: listError } = useApiAsync12(
     (params) => listSchedulerTasksApi({ ...optionsRef.current, ...params }),
     (data) => data.tasks,
     []
   );
-  const { execute: createTask, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createTask, loading: createLoading, error: createError } = useApiAsync12(
     (task) => createSchedulerTaskApi(task, optionsRef.current),
     (data) => data.task || null,
     null
   );
-  const { execute: getTask, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getTask, loading: getLoading, error: getError } = useApiAsync12(
     (taskId) => getSchedulerTaskApi(taskId, optionsRef.current),
     (data) => data.task || null,
     null
   );
-  const { execute: updateTask, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateTask, loading: updateLoading, error: updateError } = useApiAsync12(
     (taskId, task) => updateSchedulerTaskApi(taskId, task, optionsRef.current),
     (data) => data.task || null,
     null
   );
-  const { execute: deleteTask, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteTask, loading: deleteLoading, error: deleteError } = useApiAsync12(
     (taskId) => deleteSchedulerTaskApi(taskId, optionsRef.current),
     (data) => data.success,
     false
   );
-  const { execute: snoozeTask, loading: snoozeLoading, error: snoozeError } = useApiAsync(
+  const { execute: snoozeTask, loading: snoozeLoading, error: snoozeError } = useApiAsync12(
     (taskId, delay) => snoozeSchedulerTaskApi(taskId, delay, optionsRef.current),
     (data) => data.task || null,
     null
   );
-  const { execute: completeTask, loading: completeLoading, error: completeError } = useApiAsync(
+  const { execute: completeTask, loading: completeLoading, error: completeError } = useApiAsync12(
     (taskId) => completeSchedulerTaskApi(taskId, optionsRef.current),
     (data) => data.task || null,
     null
   );
-  const { execute: startTask, loading: startLoading, error: startError } = useApiAsync(
+  const { execute: startTask, loading: startLoading, error: startError } = useApiAsync12(
     (taskId) => startSchedulerTaskApi(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 useMemo(
+  return useMemo12(
     () => ({
       loading,
       error,
@@ -690,51 +709,55 @@ function useSchedulerTasks(options) {
     [loading, error, listTasks, createTask, getTask, updateTask, deleteTask, snoozeTask, completeTask, startTask]
   );
 }
+
+// hooks/use-scheduler-schedules.ts
+import { useMemo as useMemo13 } from "react";
+import { useApiAsync as useApiAsync13 } from "@elqnt/api-client/hooks";
 function useSchedulerSchedules(options) {
   const optionsRef = useOptionsRef(options);
-  const { execute: listSchedules, loading: listLoading, error: listError } = useApiAsync(
+  const { execute: listSchedules, loading: listLoading, error: listError } = useApiAsync13(
     (params) => listSchedulesApi({ ...optionsRef.current, ...params }),
     (data) => data.schedules,
     []
   );
-  const { execute: createSchedule, loading: createLoading, error: createError } = useApiAsync(
+  const { execute: createSchedule, loading: createLoading, error: createError } = useApiAsync13(
     (schedule) => createScheduleApi(schedule, optionsRef.current),
     (data) => data.schedule || null,
     null
   );
-  const { execute: getSchedule, loading: getLoading, error: getError } = useApiAsync(
+  const { execute: getSchedule, loading: getLoading, error: getError } = useApiAsync13(
     (scheduleId) => getScheduleApi(scheduleId, optionsRef.current),
     (data) => data.schedule || null,
     null
   );
-  const { execute: updateSchedule, loading: updateLoading, error: updateError } = useApiAsync(
+  const { execute: updateSchedule, loading: updateLoading, error: updateError } = useApiAsync13(
     (scheduleId, schedule) => updateScheduleApi(scheduleId, schedule, optionsRef.current),
     (data) => data.schedule || null,
     null
   );
-  const { execute: deleteSchedule, loading: deleteLoading, error: deleteError } = useApiAsync(
+  const { execute: deleteSchedule, loading: deleteLoading, error: deleteError } = useApiAsync13(
     (scheduleId) => deleteScheduleApi(scheduleId, optionsRef.current),
     (data) => data.success,
     false
   );
-  const { execute: pauseSchedule, loading: pauseLoading, error: pauseError } = useApiAsync(
+  const { execute: pauseSchedule, loading: pauseLoading, error: pauseError } = useApiAsync13(
     (scheduleId) => pauseScheduleApi(scheduleId, optionsRef.current),
     (data) => data.schedule || null,
     null
   );
-  const { execute: resumeSchedule, loading: resumeLoading, error: resumeError } = useApiAsync(
+  const { execute: resumeSchedule, loading: resumeLoading, error: resumeError } = useApiAsync13(
     (scheduleId) => resumeScheduleApi(scheduleId, optionsRef.current),
     (data) => data.schedule || null,
     null
   );
-  const { execute: runSchedule, loading: runLoading, error: runError } = useApiAsync(
+  const { execute: runSchedule, loading: runLoading, error: runError } = useApiAsync13(
     (scheduleId) => runScheduleApi(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 useMemo(
+  return useMemo13(
     () => ({
       loading,
       error,
@@ -751,9 +774,327 @@ function useSchedulerSchedules(options) {
   );
 }
 
+// hooks/use-background-agents.ts
+import { useState, useEffect as useEffect2, useRef as useRef2, useCallback, useMemo as useMemo14 } from "react";
+import { useApiAsync as useApiAsync14 } from "@elqnt/api-client/hooks";
+function useBackgroundAgents(options) {
+  const optionsRef = useOptionsRef(options);
+  const [liveStates, setLiveStates] = useState({});
+  const [watchedChats, setWatchedChats] = useState({});
+  const transportRef = useRef2(null);
+  const sseRef = useRef2(null);
+  const watchedChatKeyRef = useRef2(null);
+  useEffect2(() => {
+    const transport = createBGAgentTransport();
+    transport.connect({ streamBaseUrl: optionsRef.current.baseUrl });
+    transportRef.current = transport;
+    return () => {
+      transport.disconnect();
+      transportRef.current = null;
+    };
+  }, []);
+  const subscribedJobsRef = useRef2(/* @__PURE__ */ new Set());
+  const streamJob = useCallback((jobId) => {
+    const transport = transportRef.current;
+    if (!transport) return;
+    if (subscribedJobsRef.current.has(jobId)) return;
+    subscribedJobsRef.current.add(jobId);
+    setLiveStates((prev) => ({
+      ...prev,
+      [jobId]: prev[jobId] || { status: "running", progressLog: [], latestMessage: "Starting..." }
+    }));
+    transport.on("bg_agent.round", (event) => {
+      if (event.jobId !== jobId || !event.content) return;
+      setLiveStates((prev) => {
+        const cur = prev[jobId] || { status: "running", progressLog: [], latestMessage: "" };
+        return {
+          ...prev,
+          [jobId]: { ...cur, status: "running", progressLog: [...cur.progressLog, event.content], latestMessage: event.content }
+        };
+      });
+    });
+    transport.on("bg_agent.completed", (event) => {
+      if (event.jobId !== jobId) return;
+      subscribedJobsRef.current.delete(jobId);
+      setLiveStates((prev) => ({
+        ...prev,
+        [jobId]: { ...prev[jobId] || { progressLog: [], latestMessage: "" }, status: "completed", result: event.result, latestMessage: event.result || "Completed" }
+      }));
+    });
+    transport.on("bg_agent.failed", (event) => {
+      if (event.jobId !== jobId) return;
+      subscribedJobsRef.current.delete(jobId);
+      setLiveStates((prev) => ({
+        ...prev,
+        [jobId]: { ...prev[jobId] || { progressLog: [], latestMessage: "" }, status: "failed", error: event.error, latestMessage: event.error || "Failed" }
+      }));
+    });
+    transport.streamJob(jobId);
+  }, []);
+  const { execute: triggerAgent, loading: triggerLoading, error: triggerError } = useApiAsync14(
+    (request) => triggerBackgroundAgentApi(request, optionsRef.current),
+    (data) => data,
+    null
+  );
+  const { execute: checkStatus, loading: statusLoading, error: statusError } = useApiAsync14(
+    (jobId) => checkBackgroundAgentStatusApi(jobId, optionsRef.current),
+    (data) => data,
+    null
+  );
+  const { execute: listAgentSummaries, loading: summaryLoading, error: summaryError } = useApiAsync14(
+    () => listAgentsSummaryApi(optionsRef.current),
+    (data) => data.agents || [],
+    []
+  );
+  const createTask = useCallback(async (prompt, attachments) => {
+    const { chatServiceUrl, orgId, userId } = optionsRef.current;
+    if (!chatServiceUrl) {
+      console.error("chatServiceUrl is required for createTask");
+      return null;
+    }
+    if (!userId) {
+      console.error("userId is required for createTask");
+      return null;
+    }
+    try {
+      const createResponse = await fetch(`${chatServiceUrl}/create`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          orgId,
+          userId,
+          metadata: {
+            agentName: "background_agent",
+            background: true,
+            userId,
+            userEmail: userId,
+            originalPrompt: prompt
+          }
+        })
+      });
+      if (!createResponse.ok) {
+        const errorText = await createResponse.text();
+        console.error("Failed to create background chat:", errorText);
+        return null;
+      }
+      const createData = await createResponse.json();
+      const chatKey = createData.data?.chatKey || createData.chatKey;
+      if (!chatKey) {
+        console.error("No chatKey returned from create");
+        return null;
+      }
+      const sendResponse = await fetch(`${chatServiceUrl}/send`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          orgId,
+          userId,
+          chatKey,
+          message: {
+            role: "user",
+            content: prompt,
+            attachments: attachments || void 0
+          }
+        })
+      });
+      if (!sendResponse.ok) {
+        const errorText = await sendResponse.text();
+        console.error("Failed to send message:", errorText);
+      }
+      return chatKey;
+    } catch (err) {
+      console.error("Failed to create background task:", err);
+      return null;
+    }
+  }, []);
+  const watchChat = useCallback(async (chatKey) => {
+    const { chatServiceUrl, orgId, userId } = optionsRef.current;
+    if (!chatServiceUrl) {
+      console.error("chatServiceUrl is required for watchChat");
+      return;
+    }
+    if (!userId) {
+      console.error("userId is required for watchChat");
+      return;
+    }
+    if (sseRef.current && watchedChatKeyRef.current !== chatKey) {
+      sseRef.current.close();
+      sseRef.current = null;
+    }
+    watchedChatKeyRef.current = chatKey;
+    setWatchedChats((prev) => ({
+      ...prev,
+      [chatKey]: { chatKey, messages: [], status: "loading", statusHistory: [] }
+    }));
+    try {
+      const loadResponse = await fetch(`${chatServiceUrl}/load`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ orgId, chatKey, userId })
+      });
+      if (!loadResponse.ok) {
+        const errorText = await loadResponse.text();
+        setWatchedChats((prev) => ({
+          ...prev,
+          [chatKey]: { chatKey, messages: [], status: "error", statusHistory: [], error: errorText || "Failed to load chat" }
+        }));
+        return;
+      }
+      const loadData = await loadResponse.json();
+      const chat = loadData.data?.chat || loadData.chat;
+      if (!chat) {
+        setWatchedChats((prev) => ({
+          ...prev,
+          [chatKey]: { chatKey, messages: [], status: "error", statusHistory: [], error: "No chat data returned" }
+        }));
+        return;
+      }
+      const bgStatus = chat.metadata?.backgroundStatus;
+      const bgMessage = chat.metadata?.backgroundStatusMessage;
+      let initialStatus = "active";
+      if (bgStatus === "completed") initialStatus = "completed";
+      else if (bgStatus === "failed") initialStatus = "error";
+      const initialStatusHistory = [];
+      setWatchedChats((prev) => ({
+        ...prev,
+        [chatKey]: {
+          chatKey,
+          messages: chat.messages || [],
+          status: initialStatus,
+          title: chat.title,
+          metadata: chat.metadata,
+          backgroundStatus: bgStatus,
+          backgroundStatusMessage: bgMessage,
+          statusHistory: initialStatusHistory
+        }
+      }));
+      const sseUrl = `${chatServiceUrl}/stream?orgId=${orgId}&userId=${userId}&chatId=${chatKey}&clientType=customer`;
+      const sse = new EventSource(sseUrl);
+      sseRef.current = sse;
+      const processEventData = (data) => {
+        console.log("[useBackgroundAgents] SSE event received:", data.type, data);
+        if (data.type === "message" && data.message) {
+          setWatchedChats((prev) => {
+            const current = prev[chatKey];
+            if (!current) return prev;
+            const msg = data.message;
+            const exists = current.messages.some((m) => m.id === msg.id);
+            if (exists) return prev;
+            return {
+              ...prev,
+              [chatKey]: {
+                ...current,
+                messages: [...current.messages, msg]
+              }
+            };
+          });
+        }
+        const eventData = data.data;
+        if (data.type === "agent_context_update" && eventData?.backgroundStatus) {
+          const bgStatus2 = eventData.backgroundStatus;
+          const bgMessage2 = eventData.backgroundStatusMessage;
+          const timestamp = Date.now();
+          console.log("[useBackgroundAgents] Background status update:", bgStatus2, bgMessage2);
+          setWatchedChats((prev) => {
+            const current = prev[chatKey];
+            if (!current) return prev;
+            const newStatus = bgStatus2 === "completed" ? "completed" : bgStatus2 === "failed" ? "error" : current.status;
+            const newHistory = [...current.statusHistory];
+            const lastEntry = newHistory[newHistory.length - 1];
+            if (!lastEntry || lastEntry.message !== bgMessage2 || lastEntry.status !== bgStatus2) {
+              newHistory.push({
+                status: bgStatus2,
+                message: bgMessage2 || "",
+                timestamp
+              });
+            }
+            return {
+              ...prev,
+              [chatKey]: {
+                ...current,
+                status: newStatus,
+                backgroundStatus: bgStatus2,
+                backgroundStatusMessage: bgMessage2,
+                statusHistory: newHistory
+              }
+            };
+          });
+        }
+        if (data.type === "chat_ended" || data.type === "agent_done") {
+          setWatchedChats((prev) => ({
+            ...prev,
+            [chatKey]: { ...prev[chatKey], status: "completed" }
+          }));
+        }
+      };
+      sse.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          processEventData(data);
+        } catch (err) {
+          console.error("Failed to parse SSE event:", err);
+        }
+      };
+      const customEventTypes = ["agent_context_update", "message", "chat_ended", "agent_done"];
+      for (const eventType of customEventTypes) {
+        sse.addEventListener(eventType, (event) => {
+          try {
+            const data = JSON.parse(event.data);
+            processEventData(data);
+          } catch (err) {
+            console.error(`Failed to parse SSE ${eventType} event:`, err);
+          }
+        });
+      }
+      sse.onerror = () => {
+        console.warn("SSE connection error for chat:", chatKey);
+      };
+    } catch (err) {
+      console.error("Failed to watch chat:", err);
+      setWatchedChats((prev) => ({
+        ...prev,
+        [chatKey]: { chatKey, messages: [], status: "error", statusHistory: [], error: String(err) }
+      }));
+    }
+  }, []);
+  const unwatchChat = useCallback((chatKey) => {
+    if (watchedChatKeyRef.current === chatKey && sseRef.current) {
+      sseRef.current.close();
+      sseRef.current = null;
+      watchedChatKeyRef.current = null;
+    }
+    setWatchedChats((prev) => {
+      const next = { ...prev };
+      delete next[chatKey];
+      return next;
+    });
+  }, []);
+  useEffect2(() => {
+    return () => {
+      if (sseRef.current) {
+        sseRef.current.close();
+        sseRef.current = null;
+      }
+    };
+  }, []);
+  const loading = triggerLoading || statusLoading || summaryLoading;
+  const error = triggerError || statusError || summaryError;
+  return useMemo14(() => ({
+    liveStates,
+    streamJob,
+    createTask,
+    watchChat,
+    unwatchChat,
+    watchedChats,
+    triggerAgent,
+    checkStatus,
+    listAgentSummaries,
+    loading,
+    error
+  }), [liveStates, streamJob, createTask, watchChat, unwatchChat, watchedChats, triggerAgent, checkStatus, listAgentSummaries, loading, error]);
+}
+
 export {
-  useAsync,
-  useApiAsync,
   useOptionsRef,
   useAgents,
   useSkills,
@@ -765,7 +1106,9 @@ export {
   useAnalytics,
   useIntegrations,
   useSandbox,
+  useStructuredOutput,
   useSchedulerTasks,
-  useSchedulerSchedules
+  useSchedulerSchedules,
+  useBackgroundAgents
 };
-//# sourceMappingURL=chunk-V5GHDXSW.mjs.map
+//# sourceMappingURL=chunk-MNFZXJ2Y.mjs.map