@elqnt/agent-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,615 @@
+import { useState, useRef, useEffect, useCallback } from 'react';
+import { useWebSocketChatBase } from '@elqnt/chat';
+
+// src/hooks/useAgent/useAgent.ts
+function useAgentChat(config) {
+  const {
+    agentId,
+    orgId,
+    serverBaseUrl,
+    userEmail,
+    features = {},
+    onMessage,
+    onConnect,
+    onDisconnect,
+    onToolCall,
+    autoReconnect = true,
+    reconnectDelay = 3e3,
+    debug = false
+  } = config;
+  const [messages, setMessages] = useState([]);
+  const [currentChat, setCurrentChat] = useState(void 0);
+  const [users, setUsers] = useState([]);
+  const [currentChatUser, setCurrentChatUser] = useState(void 0);
+  const [isWaiting, setIsWaiting] = useState(false);
+  const [isWaitingForAgent, setIsWaitingForAgent] = useState(false);
+  const [chatKey, setChatKey] = useState(void 0);
+  const onMessageRef = useRef(onMessage);
+  const onToolCallRef = useRef(onToolCall);
+  useEffect(() => {
+    onMessageRef.current = onMessage;
+  }, [onMessage]);
+  useEffect(() => {
+    onToolCallRef.current = onToolCall;
+  }, [onToolCall]);
+  const handleMessage = useCallback(
+    (event) => {
+      if (debug) {
+        console.log("[useAgentChat] Received event:", event.type, event);
+      }
+      switch (event.type) {
+        case "new_chat_created":
+          const newChatKey = event.data?.chatKey;
+          if (newChatKey) {
+            setChatKey(newChatKey);
+          }
+          break;
+        case "load_chat_response":
+          const chat = event.data?.chat;
+          if (chat) {
+            setCurrentChat(chat);
+            setChatKey(chat.key);
+            setMessages(chat.messages || []);
+            setUsers(chat.users || []);
+            const currentUser = chat.users?.find((u) => u.email === userEmail);
+            setCurrentChatUser(currentUser);
+          }
+          break;
+        case "message":
+          const message = event.message;
+          if (message) {
+            setMessages((prev) => [...prev, message]);
+            if (message.role === "ai") {
+              setIsWaiting(false);
+            }
+          }
+          break;
+        case "typing":
+          setIsWaiting(true);
+          break;
+        case "waiting_for_agent":
+          setIsWaitingForAgent(true);
+          break;
+        case "agent_chat_assigned":
+          setIsWaitingForAgent(false);
+          break;
+        case "chat_ended":
+          setChatKey(void 0);
+          setCurrentChat(void 0);
+          setMessages([]);
+          setUsers([]);
+          setCurrentChatUser(void 0);
+          setIsWaiting(false);
+          setIsWaitingForAgent(false);
+          break;
+      }
+      if (onMessageRef.current) {
+        onMessageRef.current(event);
+      }
+    },
+    [debug, userEmail]
+  );
+  const baseHook = useWebSocketChatBase({
+    serverBaseUrl,
+    orgId,
+    clientType: "customer",
+    product: "hub",
+    // Default product, can be made configurable
+    onMessage: handleMessage,
+    retryConfig: autoReconnect ? {
+      maxRetries: 10,
+      intervals: [reconnectDelay, reconnectDelay * 2, reconnectDelay * 3]
+    } : { maxRetries: 0 },
+    debug
+  });
+  useEffect(() => {
+    if (baseHook.connectionState === "connected" && onConnect) {
+      onConnect();
+    } else if (baseHook.connectionState === "disconnected" && onDisconnect) {
+      onDisconnect();
+    }
+  }, [baseHook.connectionState, onConnect, onDisconnect]);
+  const sendMessage = useCallback(
+    async (content, attachments) => {
+      if (!chatKey) {
+        throw new Error("No active chat session. Call startNewChat() first.");
+      }
+      if (!content.trim()) {
+        throw new Error("Message content cannot be empty.");
+      }
+      setIsWaiting(true);
+      const now = Date.now();
+      const event = {
+        type: "message",
+        orgId,
+        chatKey,
+        userId: userEmail,
+        message: {
+          id: `msg-${now}-${Math.random().toString(36).substr(2, 9)}`,
+          role: "user",
+          content,
+          time: now,
+          status: "sending",
+          senderId: userEmail,
+          createdAt: now,
+          attachments
+        },
+        data: {}
+      };
+      try {
+        await baseHook.sendMessage(event, userEmail);
+      } catch (error2) {
+        setIsWaiting(false);
+        throw error2;
+      }
+    },
+    [chatKey, orgId, userEmail, baseHook]
+  );
+  const startNewChat = useCallback(async () => {
+    if (debug) {
+      console.log("[useAgentChat] Starting new chat...");
+    }
+    if (!baseHook.isConnected) {
+      await baseHook.connect(userEmail);
+    }
+    const newChatKey = await baseHook.startNewChat(userEmail, {
+      agentId,
+      product: "hub"
+    });
+    setChatKey(newChatKey);
+    setMessages([]);
+    setUsers([]);
+    setIsWaiting(false);
+    setIsWaitingForAgent(false);
+    if (debug) {
+      console.log("[useAgentChat] New chat created:", newChatKey);
+    }
+  }, [agentId, userEmail, baseHook, debug]);
+  const endChat = useCallback(() => {
+    if (!chatKey) return;
+    const event = {
+      type: "end_chat",
+      orgId,
+      chatKey,
+      userId: userEmail,
+      data: {}
+    };
+    baseHook.sendMessage(event, userEmail);
+    setChatKey(void 0);
+    setMessages([]);
+    setCurrentChat(void 0);
+    setUsers([]);
+    setIsWaiting(false);
+    setIsWaitingForAgent(false);
+  }, [chatKey, orgId, userEmail, baseHook]);
+  const resetChat = useCallback(() => {
+    setChatKey(void 0);
+    setMessages([]);
+    setCurrentChat(void 0);
+    setUsers([]);
+    setCurrentChatUser(void 0);
+    setIsWaiting(false);
+    setIsWaitingForAgent(false);
+  }, []);
+  const clearError = useCallback(() => {
+    baseHook.clearError();
+  }, [baseHook]);
+  useEffect(() => {
+    baseHook.connect(userEmail).catch((error2) => {
+      console.error("[useAgentChat] Failed to auto-connect:", error2);
+    });
+  }, []);
+  const error = baseHook.error ? {
+    code: baseHook.error.code,
+    message: baseHook.error.message,
+    retryable: baseHook.error.retryable,
+    timestamp: baseHook.error.timestamp
+  } : void 0;
+  return {
+    // Chat state
+    messages,
+    currentChat,
+    users,
+    currentChatUser,
+    connectionState: baseHook.connectionState,
+    isConnected: baseHook.isConnected,
+    isWaiting,
+    isWaitingForAgent,
+    status: currentChat?.status,
+    chatKey,
+    error,
+    // Chat actions
+    sendMessage,
+    startNewChat,
+    endChat,
+    resetChat,
+    disconnect: baseHook.disconnect,
+    clearError
+  };
+}
+function useAgentTools(config = {}) {
+  const {
+    tools: initialTools = {},
+    onToolExecuted,
+    onToolError,
+    debug = false
+  } = config;
+  const [tools, setTools] = useState({});
+  const toolHandlersRef = useRef(initialTools);
+  const onToolExecutedRef = useRef(onToolExecuted);
+  const onToolErrorRef = useRef(onToolError);
+  useEffect(() => {
+    onToolExecutedRef.current = onToolExecuted;
+  }, [onToolExecuted]);
+  useEffect(() => {
+    onToolErrorRef.current = onToolError;
+  }, [onToolError]);
+  useEffect(() => {
+    toolHandlersRef.current = { ...toolHandlersRef.current, ...initialTools };
+  }, [initialTools]);
+  const executeClientTool = useCallback(
+    async (toolName, params) => {
+      const startTime = Date.now();
+      if (debug) {
+        console.log(`[useAgentTools] Executing tool: ${toolName}`, params);
+      }
+      const handler = toolHandlersRef.current[toolName];
+      if (!handler) {
+        const error = {
+          code: "TOOL_EXECUTION_FAILED",
+          message: `Tool handler not found: ${toolName}`,
+          retryable: false,
+          timestamp: Date.now(),
+          details: { toolName, params }
+        };
+        if (onToolErrorRef.current) {
+          onToolErrorRef.current(toolName, error);
+        }
+        throw new Error(error.message);
+      }
+      try {
+        const result = await handler(params);
+        const executionTime = Date.now() - startTime;
+        const executionResult = {
+          success: true,
+          result,
+          executionTime
+        };
+        if (debug) {
+          console.log(
+            `[useAgentTools] Tool executed successfully: ${toolName}`,
+            executionResult
+          );
+        }
+        if (onToolExecutedRef.current) {
+          onToolExecutedRef.current(toolName, executionResult);
+        }
+        return result;
+      } catch (error) {
+        const executionTime = Date.now() - startTime;
+        const agentError = {
+          code: "TOOL_EXECUTION_FAILED",
+          message: error instanceof Error ? error.message : "Tool execution failed",
+          retryable: true,
+          timestamp: Date.now(),
+          details: { toolName, params, error }
+        };
+        const executionResult = {
+          success: false,
+          error: agentError,
+          executionTime
+        };
+        if (debug) {
+          console.error(`[useAgentTools] Tool execution failed: ${toolName}`, agentError);
+        }
+        if (onToolErrorRef.current) {
+          onToolErrorRef.current(toolName, agentError);
+        }
+        if (onToolExecutedRef.current) {
+          onToolExecutedRef.current(toolName, executionResult);
+        }
+        throw agentError;
+      }
+    },
+    [debug]
+  );
+  const registerTool = useCallback(
+    (toolName, handler) => {
+      if (debug) {
+        console.log(`[useAgentTools] Registering tool: ${toolName}`);
+      }
+      toolHandlersRef.current[toolName] = handler;
+      setTools((prev) => ({
+        ...prev,
+        [toolName]: {
+          id: toolName,
+          name: toolName,
+          title: toolName,
+          description: `Custom tool: ${toolName}`,
+          inputSchema: { type: "object", properties: {} },
+          configSchema: { type: "object", properties: {} },
+          enabled: true,
+          isSystem: false,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }));
+    },
+    [debug]
+  );
+  const unregisterTool = useCallback(
+    (toolName) => {
+      if (debug) {
+        console.log(`[useAgentTools] Unregistering tool: ${toolName}`);
+      }
+      delete toolHandlersRef.current[toolName];
+      setTools((prev) => {
+        const newTools = { ...prev };
+        delete newTools[toolName];
+        return newTools;
+      });
+    },
+    [debug]
+  );
+  const hasToolHandler = useCallback((toolName) => {
+    return toolName in toolHandlersRef.current;
+  }, []);
+  return {
+    tools,
+    executeClientTool,
+    registerTool,
+    unregisterTool,
+    hasToolHandler
+  };
+}
+
+// src/hooks/useAgent/useAgent.ts
+function useAgent(config) {
+  const {
+    agentId,
+    tools: toolHandlers = {},
+    initialMetadata = {},
+    onCSATSubmit,
+    debug = false
+  } = config;
+  const [agent, setAgent] = useState(void 0);
+  const [metadata, setMetadata] = useState(initialMetadata);
+  const [csatSurvey, setCSATSurvey] = useState(void 0);
+  const onCSATSubmitRef = useRef(onCSATSubmit);
+  useEffect(() => {
+    onCSATSubmitRef.current = onCSATSubmit;
+  }, [onCSATSubmit]);
+  const chatHook = useAgentChat({
+    ...config,
+    onMessage: (event) => {
+      if (event.type === "show_csat_survey") {
+        const survey = event.data?.survey;
+        if (survey) {
+          setCSATSurvey(survey);
+        }
+      }
+      if (event.type === "sync_metadata_response") {
+        const newMetadata = event.data?.metadata;
+        if (newMetadata) {
+          setMetadata((prev) => ({ ...prev, ...newMetadata }));
+        }
+      }
+      if (config.onMessage) {
+        config.onMessage(event);
+      }
+    },
+    onToolCall: (toolName, params) => {
+      if (toolsHook.hasToolHandler(toolName)) {
+        toolsHook.executeClientTool(toolName, params).then((result) => {
+          if (debug) {
+            console.log(`[useAgent] Tool executed: ${toolName}`, result);
+          }
+          const event = {
+            type: "tool_result",
+            orgId: config.orgId,
+            chatKey: chatHook.chatKey || "",
+            userId: config.userEmail,
+            data: {
+              toolName,
+              result,
+              success: true
+            }
+          };
+          chatHook.sendMessage(JSON.stringify(event));
+        }).catch((error) => {
+          console.error(`[useAgent] Tool execution failed: ${toolName}`, error);
+          const event = {
+            type: "tool_result",
+            orgId: config.orgId,
+            chatKey: chatHook.chatKey || "",
+            userId: config.userEmail,
+            data: {
+              toolName,
+              error: error.message,
+              success: false
+            }
+          };
+          chatHook.sendMessage(JSON.stringify(event));
+        });
+      }
+      if (config.onToolCall) {
+        config.onToolCall(toolName, params);
+      }
+    }
+  });
+  const toolsHook = useAgentTools({
+    tools: toolHandlers,
+    debug
+  });
+  const updateMetadata = useCallback(
+    (updates) => {
+      const newMetadata = { ...metadata, ...updates };
+      setMetadata(newMetadata);
+      if (chatHook.chatKey && chatHook.isConnected) {
+        const event = {
+          type: "update_metadata",
+          orgId: config.orgId,
+          chatKey: chatHook.chatKey,
+          userId: config.userEmail,
+          data: { metadata: newMetadata }
+        };
+        chatHook.sendMessage(JSON.stringify(event)).catch((error) => {
+          console.error("[useAgent] Failed to update metadata:", error);
+        });
+      }
+    },
+    [metadata, chatHook, config.orgId, config.userEmail]
+  );
+  const clearMetadata = useCallback(() => {
+    setMetadata({});
+    if (chatHook.chatKey && chatHook.isConnected) {
+      const event = {
+        type: "update_metadata",
+        orgId: config.orgId,
+        chatKey: chatHook.chatKey,
+        userId: config.userEmail,
+        data: { metadata: {} }
+      };
+      chatHook.sendMessage(JSON.stringify(event)).catch((error) => {
+        console.error("[useAgent] Failed to clear metadata:", error);
+      });
+    }
+  }, [chatHook, config.orgId, config.userEmail]);
+  const submitCSATResponse = useCallback(
+    (response) => {
+      if (!csatSurvey) {
+        console.warn("[useAgent] No CSAT survey available");
+        return;
+      }
+      const event = {
+        type: "csat_response",
+        orgId: config.orgId,
+        chatKey: chatHook.chatKey || "",
+        userId: config.userEmail,
+        data: {
+          response
+        }
+      };
+      chatHook.sendMessage(JSON.stringify(event)).then(() => {
+        setCSATSurvey(void 0);
+        if (onCSATSubmitRef.current) {
+          onCSATSubmitRef.current(response);
+        }
+      }).catch((error) => {
+        console.error("[useAgent] Failed to submit CSAT response:", error);
+      });
+    },
+    [csatSurvey, chatHook, config.orgId, config.userEmail]
+  );
+  const dismissCSAT = useCallback(() => {
+    setCSATSurvey(void 0);
+  }, []);
+  const logEvent = useCallback(
+    async (eventData) => {
+      if (!config.features?.analytics) {
+        return;
+      }
+      const event = {
+        type: "analytics_event",
+        orgId: config.orgId,
+        chatKey: chatHook.chatKey || "",
+        userId: config.userEmail,
+        data: {
+          ...eventData,
+          timestamp: Date.now(),
+          agentId
+        }
+      };
+      try {
+        await chatHook.sendMessage(JSON.stringify(event));
+      } catch (error) {
+        console.error("[useAgent] Failed to log analytics event:", error);
+      }
+    },
+    [config.features, config.orgId, config.userEmail, chatHook, agentId]
+  );
+  useEffect(() => {
+    setAgent({
+      id: agentId,
+      orgId: config.orgId,
+      product: "hub",
+      type: "react",
+      subType: "react",
+      name: agentId,
+      title: "AI Agent",
+      description: "AI-powered assistant",
+      status: "active",
+      version: "1.0.0",
+      provider: "azure-openai",
+      model: "gpt-4.1",
+      temperature: 0.7,
+      maxTokens: 4e3,
+      systemPrompt: "",
+      isDefault: false,
+      isPublic: false,
+      csatConfig: {
+        enabled: false,
+        survey: {
+          questions: [],
+          timeThreshold: 5,
+          closeOnResponse: true
+        }
+      },
+      handoffConfig: {
+        enabled: false,
+        triggerKeywords: [],
+        handoffMessage: ""
+      },
+      configSchema: {
+        type: "object",
+        properties: {}
+      },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      createdBy: config.userEmail,
+      updatedBy: config.userEmail
+    });
+  }, [agentId, config.orgId]);
+  return {
+    // Agent info
+    agent,
+    // Chat functionality (from useAgentChat)
+    messages: chatHook.messages,
+    currentChat: chatHook.currentChat,
+    users: chatHook.users,
+    currentChatUser: chatHook.currentChatUser,
+    connectionState: chatHook.connectionState,
+    isConnected: chatHook.isConnected,
+    isWaiting: chatHook.isWaiting,
+    isWaitingForAgent: chatHook.isWaitingForAgent,
+    status: chatHook.status,
+    chatKey: chatHook.chatKey,
+    error: chatHook.error,
+    sendMessage: chatHook.sendMessage,
+    startNewChat: chatHook.startNewChat,
+    endChat: chatHook.endChat,
+    resetChat: chatHook.resetChat,
+    disconnect: chatHook.disconnect,
+    clearError: chatHook.clearError,
+    // Tools functionality (from useAgentTools)
+    tools: toolsHook.tools,
+    executeClientTool: toolsHook.executeClientTool,
+    registerTool: toolsHook.registerTool,
+    unregisterTool: toolsHook.unregisterTool,
+    hasToolHandler: toolsHook.hasToolHandler,
+    // Metadata management
+    metadata,
+    updateMetadata,
+    clearMetadata,
+    // CSAT
+    csatSurvey,
+    submitCSATResponse,
+    dismissCSAT,
+    // Analytics
+    logEvent
+  };
+}
+
+export { useAgent, useAgentChat, useAgentTools };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map