@terryavg/neptune-ai-chatbot 1.0.0 → 1.0.2

package/dist/chunk-26656QB3.mjs

@@ -0,0 +1,406 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-FWCSY2DS.mjs";
+
+// app/api/chat-client.ts
+var chatConfig = {};
+function configureChatClient(config) {
+  chatConfig.username = config.username;
+  chatConfig.password = config.password;
+  chatConfig.baseUrl = config.baseUrl;
+}
+function isJson(content) {
+  if (typeof content === "object" && content !== null) {
+    return Array.isArray(content) || Object.prototype.toString.call(content) === "[object Object]";
+  }
+  if (typeof content === "string") {
+    try {
+      const parsed = JSON.parse(content);
+      return typeof parsed === "object" && parsed !== null;
+    } catch (e) {
+      return false;
+    }
+  }
+  return false;
+}
+async function fetchWithErrorHandling(url, options = {}) {
+  const headers = new Headers(options.headers);
+  headers.set("Content-Type", "application/json");
+  if (chatConfig.username && chatConfig.password) {
+    headers.set(
+      "Authorization",
+      "Basic " + btoa(chatConfig.username + ":" + chatConfig.password)
+    );
+  }
+  const finalUrl = chatConfig.baseUrl ? `${chatConfig.baseUrl}${url}` : url;
+  let response;
+  try {
+    response = await fetch(finalUrl, __spreadProps(__spreadValues({}, options), {
+      headers
+    }));
+  } catch (networkError) {
+    console.error("Network error:", networkError);
+    throw {
+      isNetworkError: true,
+      message: "Failed to connect to the server. Please check your network.",
+      status: 0
+    };
+  }
+  if (!response.ok) {
+    let errorBody = {
+      message: `API request failed: ${response.status} ${response.statusText}`,
+      statusText: response.statusText
+    };
+    try {
+      const contentType2 = response.headers.get("content-type");
+      if (contentType2 && contentType2.includes("application/json")) {
+        const jsonError = await response.json();
+        errorBody = __spreadProps(__spreadValues({}, jsonError), {
+          // Include fields like status, message from API
+          statusText: response.statusText
+          // Keep original statusText
+        });
+      } else {
+        const textError = await response.text();
+        errorBody.message = textError || errorBody.message;
+      }
+    } catch (parseError) {
+      console.error("Failed to parse error response body:", parseError);
+    }
+    throw __spreadProps(__spreadValues({}, errorBody), { status: response.status, isApiError: true });
+  }
+  const contentType = response.headers.get("content-type");
+  if (!contentType || !contentType.includes("application/json")) {
+    if (response.status === 204 || !contentType) {
+      return { success: true };
+    }
+    const text = await response.text();
+    if (!text.trim()) {
+      return { success: true };
+    }
+    console.warn(
+      `API returned non-JSON response for ${url}, status: ${response.status}`
+    );
+    return { success: true, nonJsonResponse: text };
+  }
+  return response.json();
+}
+async function createAgentStream(agentId, messages, conversationId, signal, stepData, streaming = true) {
+  const lastMessage = messages[messages.length - 1];
+  let input = "";
+  if (lastMessage && lastMessage.content) {
+    if (typeof lastMessage.content === "string") {
+      input = lastMessage.content;
+    } else if (Array.isArray(lastMessage.content)) {
+      const textContent = lastMessage.content.find(
+        (c) => c.type === "text"
+      );
+      if (textContent) {
+        input = textContent.text;
+      }
+    }
+  }
+  const formData = new FormData();
+  formData.append("aiAgent", agentId);
+  formData.append("input", input);
+  formData.append("stream", streaming ? "true" : "false");
+  if (conversationId && conversationId.trim() !== "" && !conversationId.startsWith("temp-")) {
+    formData.append("threadID", conversationId);
+  }
+  if (stepData) {
+    formData.append("variables", JSON.stringify(stepData));
+  }
+  if (lastMessage && Array.isArray(lastMessage.content)) {
+    for (const content of lastMessage.content) {
+      if (content.type === "image") {
+        const imageContent = content;
+        const base64Data = imageContent.image.includes(",") ? imageContent.image.split(",")[1] : imageContent.image;
+        const byteCharacters = atob(base64Data);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+          byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        const blob = new Blob([byteArray], {
+          type: imageContent.mediaType
+        });
+        const file = new File(
+          [blob],
+          `image.${imageContent.mediaType.split("/")[1]}`,
+          {
+            type: imageContent.mediaType
+          }
+        );
+        formData.append("files", file);
+      } else if (content.type === "file") {
+        const fileContent = content;
+        const base64Data = fileContent.data.includes(",") ? fileContent.data.split(",")[1] : fileContent.data;
+        const byteCharacters = atob(base64Data);
+        const byteNumbers = new Array(byteCharacters.length);
+        for (let i = 0; i < byteCharacters.length; i++) {
+          byteNumbers[i] = byteCharacters.charCodeAt(i);
+        }
+        const byteArray = new Uint8Array(byteNumbers);
+        const blob = new Blob([byteArray], {
+          type: fileContent.mediaType
+        });
+        const file = new File([blob], fileContent.filename, {
+          type: fileContent.mediaType
+        });
+        formData.append("files", file);
+      }
+    }
+  }
+  const url = chatConfig.baseUrl ? `${chatConfig.baseUrl}/api/AIBuildersKit/createCompletionAI` : "/api/AIBuildersKit/createCompletionAI";
+  const headers = {};
+  if (chatConfig.username && chatConfig.password) {
+    headers["Authorization"] = "Basic " + btoa(chatConfig.username + ":" + chatConfig.password);
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: formData,
+    signal
+  });
+  if (!response.ok) {
+    let errorDetails = `API request failed: ${response.status} ${response.statusText}`;
+    try {
+      const errorData = await response.json();
+      if (errorData && errorData.message) {
+        errorDetails = errorData.message;
+      }
+    } catch (e) {
+    }
+    throw new Error(errorDetails);
+  }
+  if (!response.body) {
+    throw new Error("Stream not supported by the response");
+  }
+  return response.body;
+}
+var chatClient = {
+  conversations: {
+    getAll: async (agentId) => {
+      const response = await fetchWithErrorHandling(
+        "/api/functions/AIAgent/listUserThreads",
+        {
+          method: "POST",
+          body: JSON.stringify({ agentId })
+        }
+      );
+      if (Array.isArray(response)) {
+        return response;
+      } else if (response && response.conversations && Array.isArray(response.conversations)) {
+        return response.conversations;
+      } else if (response && response.data && Array.isArray(response.data)) {
+        return response.data;
+      } else {
+        console.error(
+          "Unexpected response format from list-conversations:",
+          response
+        );
+        return [];
+      }
+    },
+    get: async (id) => {
+      const response = await fetchWithErrorHandling(
+        `/api/functions/AIAgent/getConversation`,
+        {
+          method: "POST",
+          body: JSON.stringify({ id })
+        }
+      );
+      if (Array.isArray(response)) {
+        const logs = response;
+        const messages = [];
+        logs.forEach((log) => {
+          let userContent = log.input;
+          if (log.files && log.files.length > 0) {
+            const contentParts = [];
+            if (log.input && log.input.trim()) {
+              contentParts.push({
+                type: "text",
+                text: log.input
+              });
+            }
+            log.files.forEach((file) => {
+              if (file.mimeType.startsWith("image/")) {
+                contentParts.push({
+                  type: "image",
+                  image: `data:${file.mimeType};base64,${file.data}`,
+                  mediaType: file.mimeType
+                });
+              } else {
+                contentParts.push({
+                  type: "file",
+                  data: `data:${file.mimeType};base64,${file.data}`,
+                  mediaType: file.mimeType,
+                  filename: file.name
+                });
+              }
+            });
+            userContent = contentParts;
+          }
+          messages.push({
+            id: `${log.id}-user`,
+            content: userContent,
+            role: "user",
+            createdAt: log.createdAt
+          });
+          const assistantMessage = {
+            id: `${log.id}-assistant`,
+            content: log.output,
+            role: "assistant",
+            createdAt: log.updatedAt
+          };
+          if (log.steps && log.steps.length > 0 || log.vectors && log.vectors.length > 0) {
+            assistantMessage.metadata = {
+              logId: log.id,
+              steps: log.steps,
+              vectors: log.vectors
+            };
+          }
+          messages.push(assistantMessage);
+        });
+        const conversation2 = {
+          id,
+          title: logs.length > 0 ? logs[0].input.substring(0, 50) : "Conversation",
+          messages,
+          createdAt: logs.length > 0 ? logs[0].createdAt : (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: logs.length > 0 ? logs[logs.length - 1].updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return conversation2;
+      }
+      let conversation;
+      if (response && response.id) {
+        conversation = response;
+      } else if (response && response.conversation) {
+        conversation = response.conversation;
+      } else if (response && response.data) {
+        conversation = response.data;
+      } else {
+        throw new Error(
+          "Unexpected response format from get-conversation"
+        );
+      }
+      if (conversation.messages && Array.isArray(conversation.messages)) {
+        conversation.messages = conversation.messages.map((message) => {
+          if (message.role === "assistant" && typeof message.content === "string") {
+            const content = message.content;
+            if (isJson(content) && !content.includes("```json:")) {
+              const jsonObj = typeof content === "string" ? JSON.parse(content) : content;
+              return __spreadProps(__spreadValues({}, message), {
+                content: `\`\`\`json:Response
+${JSON.stringify(
+                  jsonObj,
+                  null,
+                  2
+                )}
+\`\`\``
+              });
+            }
+          }
+          return message;
+        });
+      }
+      return conversation;
+    },
+    create: async (title, agentId) => {
+      return fetchWithErrorHandling(
+        `/api/functions/AIAgent/createThread`,
+        {
+          method: "POST",
+          body: JSON.stringify(__spreadValues(__spreadValues({}, title ? { title } : {}), agentId ? { agentId } : {}))
+        }
+      );
+    },
+    delete: async (id) => {
+      return fetchWithErrorHandling(
+        `/api/functions/AIAgent/deleteThreadByIdAndUser`,
+        {
+          method: "POST",
+          body: JSON.stringify({ id })
+        }
+      );
+    },
+    update: async (id, data) => {
+      return fetchWithErrorHandling(
+        `/api/functions/AIAgent/renameThread`,
+        {
+          method: "POST",
+          body: JSON.stringify({ id, title: data.title })
+        }
+      );
+    }
+  },
+  messages: {
+    getLastMessages: async (conversationId, limit = 100) => {
+      const conversation = await chatClient.conversations.get(
+        conversationId
+      );
+      return conversation.messages.slice(-limit);
+    },
+    sendMessage: async (agentId, conversationId, content, existingMessages, signal, debug, stepData, isTemporary, streaming = true) => {
+      const idToUse = agentId;
+      if (!idToUse || typeof idToUse !== "string" || idToUse.trim() === "") {
+        const error = new Error(
+          "Assistant or Agent ID is missing or invalid. Please provide a valid Assistant or Agent ID in the URL."
+        );
+        error.isConfigurationError = true;
+        error.status = 400;
+        throw error;
+      }
+      let actualConversationId = conversationId;
+      if (isTemporary && agentId) {
+        let title = "New Chat";
+        if (typeof content === "string") {
+          title = content.substring(0, 50);
+        } else if (Array.isArray(content)) {
+          const textContent = content.find(
+            (c) => c.type === "text"
+          );
+          if (textContent) {
+            title = textContent.text.substring(0, 50);
+          }
+        }
+        try {
+          const newConversation = await chatClient.conversations.create(title, agentId);
+          actualConversationId = newConversation.id;
+        } catch (error) {
+          console.error("Failed to create conversation:", error);
+          throw error;
+        }
+      }
+      const userMessage = {
+        role: "user",
+        content
+      };
+      let contextMessages = [];
+      if (existingMessages && Array.isArray(existingMessages)) {
+        const formattedMessages = existingMessages.map((msg) => ({
+          role: msg.role,
+          content: msg.content
+        }));
+        contextMessages = [...formattedMessages, userMessage];
+        contextMessages = contextMessages.slice(-10);
+      } else {
+        contextMessages = [userMessage];
+      }
+      const stream = await createAgentStream(
+        idToUse,
+        contextMessages,
+        actualConversationId,
+        signal,
+        stepData,
+        streaming
+      );
+      return { stream, threadId: actualConversationId };
+    }
+  }
+};
+
+export {
+  configureChatClient,
+  chatClient
+};

package/dist/chunk-2RXQ2EZ2.mjs

@@ -0,0 +1,295 @@
+// app/components/tool-execution.tsx
+import { useState, memo, useMemo } from "react";
+import {
+  ChevronDown,
+  ChevronRight,
+  Loader2,
+  CheckCircle2,
+  XCircle,
+  Copy,
+  Check
+} from "lucide-react";
+import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
+import {
+  vscDarkPlus,
+  oneLight
+} from "react-syntax-highlighter/dist/esm/styles/prism";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ToolExecutionIndicator = memo(
+  ({ toolName }) => {
+    return /* @__PURE__ */ jsx("div", { className: "my-4 p-4 border border-blue-200 dark:border-blue-800 rounded-lg bg-blue-50 dark:bg-blue-950/30 animate-pulse", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3", children: [
+      /* @__PURE__ */ jsx(
+        Loader2,
+        {
+          size: 20,
+          className: "text-blue-600 dark:text-blue-400 animate-spin"
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "flex-1", children: [
+        /* @__PURE__ */ jsx("div", { className: "font-semibold text-blue-900 dark:text-blue-100", children: "Executing Tool" }),
+        /* @__PURE__ */ jsx("div", { className: "text-sm text-blue-700 dark:text-blue-300 mt-0.5", children: toolName })
+      ] })
+    ] }) });
+  }
+);
+ToolExecutionIndicator.displayName = "ToolExecutionIndicator";
+var ToolCallDetail = memo(
+  ({ tool, theme }) => {
+    const [isExpanded, setIsExpanded] = useState(false);
+    const [copiedField, setCopiedField] = useState(null);
+    const isDark = theme === "dark";
+    const syntaxTheme = isDark ? vscDarkPlus : oneLight;
+    const bgColor = isDark ? "#1e1e1e" : "#efefef";
+    const formatJson = (obj) => {
+      try {
+        return JSON.stringify(obj, null, 2);
+      } catch (error) {
+        return String(obj);
+      }
+    };
+    const handleCopy = (content, fieldName) => {
+      navigator.clipboard.writeText(content).then(() => {
+        setCopiedField(fieldName);
+        setTimeout(() => setCopiedField(null), 2e3);
+      }).catch((err) => console.error("Failed to copy: ", err));
+    };
+    const getStatusIcon = () => {
+      if (tool.status === "SUCCESS") {
+        return /* @__PURE__ */ jsx(
+          CheckCircle2,
+          {
+            size: 16,
+            className: "text-green-600 dark:text-green-400"
+          }
+        );
+      } else if (tool.error) {
+        return /* @__PURE__ */ jsx(
+          XCircle,
+          {
+            size: 16,
+            className: "text-red-600 dark:text-red-400"
+          }
+        );
+      }
+      return null;
+    };
+    const getStatusColor = () => {
+      if (tool.status === "SUCCESS") {
+        return "bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300";
+      } else if (tool.error) {
+        return "bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300";
+      }
+      return "bg-gray-100 dark:bg-gray-700 text-gray-700 dark:text-gray-300";
+    };
+    const argsString = useMemo(() => formatJson(tool.args), [tool.args]);
+    const resultString = useMemo(
+      () => formatJson(tool.result),
+      [tool.result]
+    );
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "my-4 border-2 border-gray-300 dark:border-gray-600 rounded-lg overflow-hidden bg-white dark:bg-gray-900 shadow-sm",
+        children: [
+          /* @__PURE__ */ jsx(
+            "div",
+            {
+              onClick: () => setIsExpanded(!isExpanded),
+              className: "flex items-center justify-between p-3 cursor-pointer hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors bg-white dark:bg-gray-900",
+              children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 flex-1 min-w-0", children: [
+                isExpanded ? /* @__PURE__ */ jsx(
+                  ChevronDown,
+                  {
+                    size: 18,
+                    className: "text-gray-600 dark:text-gray-300 flex-shrink-0"
+                  }
+                ) : /* @__PURE__ */ jsx(
+                  ChevronRight,
+                  {
+                    size: 18,
+                    className: "text-gray-600 dark:text-gray-300 flex-shrink-0"
+                  }
+                ),
+                getStatusIcon(),
+                /* @__PURE__ */ jsx("span", { className: "font-mono text-sm font-semibold text-gray-900 dark:text-gray-100 truncate", children: tool.toolName }),
+                /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    className: `text-xs px-2 py-0.5 rounded-full flex-shrink-0 ${getStatusColor()}`,
+                    children: tool.status
+                  }
+                )
+              ] })
+            }
+          ),
+          isExpanded && /* @__PURE__ */ jsxs("div", { className: "border-t border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-900/50", children: [
+            /* @__PURE__ */ jsxs("div", { className: "p-3 border-b border-gray-200 dark:border-gray-700 bg-white dark:bg-gray-800", children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between mb-2", children: [
+                /* @__PURE__ */ jsx("span", { className: "text-xs font-semibold text-gray-700 dark:text-gray-300 uppercase", children: "Input" }),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: (e) => {
+                      e.stopPropagation();
+                      handleCopy(argsString, "input");
+                    },
+                    className: "p-1 hover:bg-gray-200 dark:hover:bg-gray-700 rounded transition-colors",
+                    title: "Copy input",
+                    children: copiedField === "input" ? /* @__PURE__ */ jsx(
+                      Check,
+                      {
+                        size: 14,
+                        className: "text-green-600"
+                      }
+                    ) : /* @__PURE__ */ jsx(
+                      Copy,
+                      {
+                        size: 14,
+                        className: "text-gray-500 dark:text-gray-400"
+                      }
+                    )
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx(
+                SyntaxHighlighter,
+                {
+                  language: "json",
+                  style: syntaxTheme,
+                  customStyle: {
+                    margin: 0,
+                    background: bgColor,
+                    fontSize: "0.875rem",
+                    padding: "1rem"
+                  },
+                  codeTagProps: {
+                    style: {
+                      backgroundColor: bgColor
+                    }
+                  },
+                  children: argsString
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "p-3 bg-white dark:bg-gray-800", children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between mb-2", children: [
+                /* @__PURE__ */ jsx("span", { className: "text-xs font-semibold text-gray-700 dark:text-gray-300 uppercase", children: "Output" }),
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    onClick: (e) => {
+                      e.stopPropagation();
+                      handleCopy(resultString, "output");
+                    },
+                    className: "p-1 hover:bg-gray-200 dark:hover:bg-gray-700 rounded transition-colors",
+                    title: "Copy output",
+                    children: copiedField === "output" ? /* @__PURE__ */ jsx(
+                      Check,
+                      {
+                        size: 14,
+                        className: "text-green-600"
+                      }
+                    ) : /* @__PURE__ */ jsx(
+                      Copy,
+                      {
+                        size: 14,
+                        className: "text-gray-500 dark:text-gray-400"
+                      }
+                    )
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx(
+                SyntaxHighlighter,
+                {
+                  language: "json",
+                  style: syntaxTheme,
+                  customStyle: {
+                    margin: 0,
+                    background: bgColor,
+                    fontSize: "0.875rem",
+                    padding: "1rem"
+                  },
+                  codeTagProps: {
+                    style: {
+                      backgroundColor: bgColor
+                    }
+                  },
+                  children: tool.error ? tool.error : resultString
+                }
+              )
+            ] })
+          ] })
+        ]
+      }
+    );
+  }
+);
+ToolCallDetail.displayName = "ToolCallDetail";
+var ToolExecutionWidget = memo(
+  ({ steps, theme }) => {
+    const [isExpanded, setIsExpanded] = useState(false);
+    const allTools = useMemo(() => {
+      return steps.filter((step) => step.tools && step.tools.length > 0).flatMap((step) => step.tools || []);
+    }, [steps]);
+    if (allTools.length === 0) {
+      return null;
+    }
+    const successCount = allTools.filter(
+      (t) => t.status === "SUCCESS"
+    ).length;
+    const errorCount = allTools.filter((t) => t.error).length;
+    return /* @__PURE__ */ jsxs("div", { className: "my-4 border-2 border-gray-300 dark:border-gray-600 rounded-lg overflow-hidden bg-white dark:bg-gray-900 shadow-sm", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          onClick: () => setIsExpanded(!isExpanded),
+          className: "flex items-center justify-between p-3 cursor-pointer hover:bg-gray-50 dark:hover:bg-gray-800 transition-colors",
+          children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            isExpanded ? /* @__PURE__ */ jsx(
+              ChevronDown,
+              {
+                size: 20,
+                className: "text-gray-600 dark:text-gray-300"
+              }
+            ) : /* @__PURE__ */ jsx(
+              ChevronRight,
+              {
+                size: 20,
+                className: "text-gray-600 dark:text-gray-300"
+              }
+            ),
+            /* @__PURE__ */ jsx("span", { className: "font-semibold text-gray-800 dark:text-white", children: "Tool Execution" }),
+            /* @__PURE__ */ jsxs("span", { className: "text-xs px-2 py-0.5 bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-300 rounded-full", children: [
+              allTools.length,
+              " ",
+              allTools.length === 1 ? "tool" : "tools"
+            ] }),
+            successCount > 0 && /* @__PURE__ */ jsxs("span", { className: "text-xs px-2 py-0.5 bg-green-100 dark:bg-green-900/30 text-green-700 dark:text-green-300 rounded-full flex items-center gap-1", children: [
+              /* @__PURE__ */ jsx(CheckCircle2, { size: 12 }),
+              successCount
+            ] }),
+            errorCount > 0 && /* @__PURE__ */ jsxs("span", { className: "text-xs px-2 py-0.5 bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-300 rounded-full flex items-center gap-1", children: [
+              /* @__PURE__ */ jsx(XCircle, { size: 12 }),
+              errorCount
+            ] })
+          ] })
+        }
+      ),
+      isExpanded && /* @__PURE__ */ jsx("div", { className: "border-t border-gray-200 dark:border-gray-700 p-3 space-y-2 bg-gray-50 dark:bg-gray-800", children: allTools.map((tool) => /* @__PURE__ */ jsx(
+        ToolCallDetail,
+        {
+          tool,
+          theme
+        },
+        tool.id
+      )) })
+    ] });
+  }
+);
+ToolExecutionWidget.displayName = "ToolExecutionWidget";
+
+export {
+  ToolExecutionIndicator,
+  ToolExecutionWidget
+};