@terryavg/neptune-ai-chatbot 1.0.2 → 1.0.3

package/dist/chunk-VONUV37R.mjs

@@ -0,0 +1,268 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-FWCSY2DS.mjs";
+
+// app/api/chat-client.ts
+var chatConfig = {};
+function configureChatClient(config) {
+  Object.assign(chatConfig, config);
+}
+var base64ToFile = (data, type, name) => {
+  const b64 = data.includes(",") ? data.split(",")[1] : data;
+  const bin = atob(b64);
+  const arr = new Uint8Array(bin.length).map((_, i) => bin.charCodeAt(i));
+  return new File([new Blob([arr], { type })], name, { type });
+};
+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;
+  try {
+    const res = await fetch(finalUrl, __spreadProps(__spreadValues({}, options), { headers }));
+    const contentType = res.headers.get("content-type");
+    const isJson = contentType == null ? void 0 : contentType.includes("application/json");
+    if (!res.ok) {
+      const err = isJson ? await res.json() : { message: await res.text() };
+      throw __spreadProps(__spreadValues({}, err), {
+        status: res.status,
+        statusText: res.statusText,
+        isApiError: true
+      });
+    }
+    if (res.status === 204 || !contentType) return { success: true };
+    return isJson ? res.json() : { success: true, nonJsonResponse: await res.text() };
+  } catch (error) {
+    if (error.isApiError) throw error;
+    throw {
+      isNetworkError: true,
+      message: "Network connection failed",
+      status: 0,
+      originalError: error
+    };
+  }
+}
+async function createAgentStream(agentId, messages, conversationId, signal, stepData, streaming = true) {
+  var _a;
+  const lastMsg = messages[messages.length - 1];
+  let input = "";
+  if (typeof (lastMsg == null ? void 0 : lastMsg.content) === "string") input = lastMsg.content;
+  else if (Array.isArray(lastMsg == null ? void 0 : lastMsg.content))
+    input = ((_a = lastMsg.content.find((c) => c.type === "text")) == null ? void 0 : _a.text) || "";
+  const formData = new FormData();
+  formData.append("aiAgent", agentId);
+  formData.append("input", input);
+  formData.append("stream", String(streaming));
+  if (conversationId && !conversationId.startsWith("temp-"))
+    formData.append("threadID", conversationId);
+  if (stepData) formData.append("variables", JSON.stringify(stepData));
+  if (Array.isArray(lastMsg == null ? void 0 : lastMsg.content)) {
+    lastMsg.content.forEach((c) => {
+      if (c.type === "image")
+        formData.append(
+          "files",
+          base64ToFile(
+            c.image,
+            c.mediaType,
+            `image.${c.mediaType.split("/")[1]}`
+          )
+        );
+      else if (c.type === "file")
+        formData.append(
+          "files",
+          base64ToFile(c.data, c.mediaType, c.filename)
+        );
+    });
+  }
+  const url = chatConfig.baseUrl ? `${chatConfig.baseUrl}/api/AIBuildersKit/createCompletionAI` : "/api/AIBuildersKit/createCompletionAI";
+  const headers = chatConfig.username ? {
+    Authorization: "Basic " + btoa(`${chatConfig.username}:${chatConfig.password}`)
+  } : {};
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: formData,
+    signal
+  });
+  if (!response.ok)
+    throw new Error(
+      (await response.json().catch(() => ({}))).message || response.statusText
+    );
+  if (!response.body) throw new Error("Stream not supported");
+  return response.body;
+}
+var chatClient = {
+  conversations: {
+    getAll: async (agentId) => {
+      const res = await fetchWithErrorHandling(
+        "/api/functions/AIAgent/listUserThreads",
+        { method: "POST", body: JSON.stringify({ agentId }) }
+      );
+      return Array.isArray(res) ? res : res.conversations || res.data || [];
+    },
+    get: async (id) => {
+      var _a, _b, _c;
+      const res = await fetchWithErrorHandling(
+        `/api/functions/AIAgent/getConversation`,
+        { method: "POST", body: JSON.stringify({ id }) }
+      );
+      if (Array.isArray(res)) {
+        const messages = res.flatMap((log) => {
+          var _a2, _b2, _c2, _d;
+          let userContent = log.input;
+          if ((_a2 = log.files) == null ? void 0 : _a2.length) {
+            userContent = [
+              ...((_b2 = log.input) == null ? void 0 : _b2.trim()) ? [
+                {
+                  type: "text",
+                  text: log.input
+                }
+              ] : [],
+              ...log.files.map(
+                (f) => f.mimeType.startsWith("image/") ? {
+                  type: "image",
+                  image: `data:${f.mimeType};base64,${f.data}`,
+                  mediaType: f.mimeType
+                } : {
+                  type: "file",
+                  data: `data:${f.mimeType};base64,${f.data}`,
+                  mediaType: f.mimeType,
+                  filename: f.name
+                }
+              )
+            ];
+          }
+          const asstMsg = {
+            id: `${log.id}-assistant`,
+            content: log.output,
+            role: "assistant",
+            createdAt: log.updatedAt
+          };
+          if (((_c2 = log.steps) == null ? void 0 : _c2.length) || ((_d = log.vectors) == null ? void 0 : _d.length) || log.feedbackPositive !== void 0) {
+            asstMsg.metadata = {
+              logId: log.id,
+              steps: log.steps,
+              vectors: log.vectors,
+              feedbackPositive: log.feedbackPositive
+            };
+          }
+          return [
+            {
+              id: `${log.id}-user`,
+              content: userContent,
+              role: "user",
+              createdAt: log.createdAt
+            },
+            asstMsg
+          ];
+        });
+        return {
+          id,
+          title: ((_a = res[0]) == null ? void 0 : _a.input.substring(0, 50)) || "Conversation",
+          messages,
+          createdAt: ((_b = res[0]) == null ? void 0 : _b.createdAt) || (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: ((_c = res[res.length - 1]) == null ? void 0 : _c.updatedAt) || (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+      const conv = res.conversation || res.data || res;
+      if (conv.messages) {
+        conv.messages = conv.messages.map((m) => {
+          if (m.role === "assistant" && typeof m.content === "string") {
+            try {
+              const parsed = JSON.parse(m.content);
+              if (typeof parsed === "object" && parsed !== null && !m.content.includes("```json:")) {
+                return __spreadProps(__spreadValues({}, m), {
+                  content: `\`\`\`json:Response
+${JSON.stringify(
+                    parsed,
+                    null,
+                    2
+                  )}
+\`\`\``
+                });
+              }
+            } catch (e) {
+            }
+          }
+          return m;
+        });
+      }
+      return conv;
+    },
+    create: (title, agentId) => fetchWithErrorHandling(`/api/functions/AIAgent/createThread`, {
+      method: "POST",
+      body: JSON.stringify(__spreadValues(__spreadValues({}, title && { title }), agentId && { agentId }))
+    }),
+    delete: (id) => fetchWithErrorHandling(
+      `/api/functions/AIAgent/deleteThreadByIdAndUser`,
+      { method: "POST", body: JSON.stringify({ id }) }
+    ),
+    update: (id, data) => fetchWithErrorHandling(`/api/functions/AIAgent/renameThread`, {
+      method: "POST",
+      body: JSON.stringify({ id, title: data.title })
+    })
+  },
+  messages: {
+    getLastMessages: async (conversationId, limit = 100) => (await chatClient.conversations.get(conversationId)).messages.slice(
+      -limit
+    ),
+    sendMessage: async (agentId, conversationId, content, existingMessages, signal, stepData, isTemporary, streaming = true) => {
+      var _a;
+      if (!agentId)
+        throw {
+          isConfigurationError: true,
+          status: 400,
+          message: "Assistant ID missing"
+        };
+      let actualId = conversationId;
+      let createdConv;
+      if (isTemporary && agentId) {
+        const titleText = typeof content === "string" ? content : ((_a = content.find(
+          (c) => c.type === "text"
+        )) == null ? void 0 : _a.text) || "";
+        createdConv = await chatClient.conversations.create(
+          titleText.substring(0, 50) || "New Chat",
+          agentId
+        );
+        actualId = createdConv.id;
+      }
+      const context = [
+        ...(existingMessages == null ? void 0 : existingMessages.map((m) => ({
+          role: m.role,
+          content: m.content
+        }))) || [],
+        { role: "user", content }
+      ].slice(-10);
+      return {
+        stream: await createAgentStream(
+          agentId,
+          context,
+          actualId,
+          signal,
+          stepData,
+          streaming
+        ),
+        threadId: actualId,
+        conversation: createdConv
+      };
+    }
+  },
+  feedback: {
+    submit: (id, feedbackPositive, aiAgent) => fetchWithErrorHandling("/api/AIBuildersKit/giveAgentFeedbackAI", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ id, feedbackPositive, aiAgent })
+    })
+  }
+};
+
+export {
+  configureChatClient,
+  chatClient
+};

package/dist/chunk-XQVUOR36.mjs

@@ -0,0 +1,438 @@
+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 || log.feedbackPositive !== void 0) {
+            assistantMessage.metadata = {
+              logId: log.id,
+              steps: log.steps,
+              vectors: log.vectors,
+              feedbackPositive: log.feedbackPositive
+            };
+          }
+          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;
+      let createdConversation = void 0;
+      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;
+          createdConversation = newConversation;
+        } 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,
+        conversation: createdConversation
+      };
+    }
+  },
+  feedback: {
+    /**
+     * Submit feedback for an AI response
+     * @param logId - The ID of the log/message
+     * @param feedbackPositive - true for like, false for dislike
+     * @param aiAgent - The agent ID
+     */
+    submit: async (logId, feedbackPositive, aiAgent) => {
+      const response = await fetchWithErrorHandling(
+        "/api/AIBuildersKit/giveAgentFeedbackAI",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            id: logId,
+            feedbackPositive,
+            aiAgent
+          })
+        }
+      );
+      return response;
+    }
+  }
+};
+
+export {
+  configureChatClient,
+  chatClient
+};