@terryavg/neptune-ai-chatbot 1.0.1 → 1.0.2

package/dist/chunk-DVWFDUN4.mjs

@@ -0,0 +1,407 @@
+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
+        });
+        console.log("Parsed API error response:", errorBody);
+      } else {
+        const textError = await response.text();
+        errorBody.message = textError || errorBody.message;
+        console.log("Non-JSON API error response:", textError);
+      }
+    } 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) {
+            assistantMessage.metadata = {
+              logId: log.id,
+              steps: log.steps
+            };
+          }
+          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
+};