@budibase/frontend-core 3.23.47 → 3.23.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@budibase/frontend-core",
-  "version": "3.23.47",
+  "version": "3.23.48",
   "description": "Budibase frontend core libraries used in builder and client",
   "author": "Budibase",
   "license": "MPL-2.0",
@@ -12,11 +12,11 @@
     "@budibase/bbui": "*",
     "@budibase/shared-core": "*",
     "@budibase/types": "*",
-    "ai": "^5.0.93",
+    "ai": "^6.0.3",
     "dayjs": "^1.10.8",
     "lodash": "4.17.21",
     "shortid": "2.2.15",
     "socket.io-client": "^4.7.5"
   },
-  "gitHead": "534845c38ed0fe209406ebe45fd87f3de79f1da5"
+  "gitHead": "0a78faa2adbb8fb3b81de2b9b00352e60178f12f"
 }

package/src/api/agents.ts

@@ -1,29 +1,15 @@
 import {
-  AgentChat,
-  ChatAgentRequest,
   CreateAgentRequest,
   CreateAgentResponse,
-  FetchAgentHistoryResponse,
   FetchAgentsResponse,
   ToolMetadata,
   UpdateAgentRequest,
   UpdateAgentResponse,
 } from "@budibase/types"
 
-import { Header } from "@budibase/shared-core"
 import { BaseAPIClient } from "./types"
-import { readUIMessageStream, UIMessage, UIMessageChunk } from "ai"
-import { createSseToJsonTransformStream } from "../utils/utils"
 
 export interface AgentEndpoints {
-  agentChatStream: (
-    chat: AgentChat,
-    workspaceId: string
-  ) => Promise<AsyncIterable<UIMessage>>
-
-  removeChat: (chatId: string) => Promise<void>
-  fetchChats: (agentId: string) => Promise<FetchAgentHistoryResponse>
-
   fetchTools: () => Promise<ToolMetadata[]>
   fetchAgents: () => Promise<FetchAgentsResponse>
   createAgent: (agent: CreateAgentRequest) => Promise<CreateAgentResponse>
@@ -31,71 +17,7 @@ export interface AgentEndpoints {
   deleteAgent: (agentId: string) => Promise<{ deleted: true }>
 }
 
-const throwOnErrorChunk = () =>
-  new TransformStream<UIMessageChunk, UIMessageChunk>({
-    transform(chunk, controller) {
-      if (chunk.type === "error") {
-        throw new Error(chunk.errorText || "Agent action failed")
-      }
-      controller.enqueue(chunk)
-    },
-  })
-
 export const buildAgentEndpoints = (API: BaseAPIClient): AgentEndpoints => ({
-  agentChatStream: async (chat, workspaceId) => {
-    const body: ChatAgentRequest = chat
-
-    const response = await fetch("/api/agent/chat/stream", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        [Header.APP_ID]: workspaceId,
-      },
-      body: JSON.stringify(body),
-      credentials: "same-origin",
-    })
-
-    if (!response.ok) {
-      const errorBody = await response.json()
-      throw new Error(
-        errorBody.message || `HTTP error! status: ${response.status}`
-      )
-    }
-
-    if (!response.body) {
-      throw new Error("Failed to get response body")
-    }
-
-    const chunkStream = response.body
-      .pipeThrough(new TextDecoderStream())
-      .pipeThrough(createSseToJsonTransformStream<UIMessageChunk>())
-      .pipeThrough(throwOnErrorChunk())
-
-    return readUIMessageStream({
-      stream: chunkStream,
-      terminateOnError: true,
-    })
-  },
-
-  removeChat: async (chatId: string) => {
-    return await API.delete({
-      url: `/api/agent/chats/${chatId}`,
-    })
-  },
-
-  fetchChats: async (agentId: string) => {
-    return await API.get({
-      url: `/api/agent/${agentId}/chats`,
-    })
-  },
-
-  fetchTools: async () => {
-    return await API.get({
-      url: `/api/agent/tools`,
-    })
-  },
-
   fetchAgents: async () => {
     return await API.get({
       url: "/api/agent",
@@ -121,4 +43,10 @@ export const buildAgentEndpoints = (API: BaseAPIClient): AgentEndpoints => ({
       url: `/api/agent/${agentId}`,
     })
   },
+
+  fetchTools: async () => {
+    return await API.get({
+      url: `/api/agent/tools`,
+    })
+  },
 })

package/src/api/chatApps.ts

@@ -0,0 +1,190 @@
+import {
+  ChatAgentRequest,
+  ChatConversation,
+  ChatConversationRequest,
+  CreateChatConversationRequest,
+  ChatApp,
+  FetchAgentHistoryResponse,
+  UpdateChatAppRequest,
+} from "@budibase/types"
+import { Header } from "@budibase/shared-core"
+import { BaseAPIClient } from "./types"
+import { readUIMessageStream, UIMessage, UIMessageChunk } from "ai"
+import { createSseToJsonTransformStream } from "../utils/utils"
+
+export interface ChatAppEndpoints {
+  streamChatConversation: (
+    chat: ChatConversationRequest,
+    workspaceId: string
+  ) => Promise<AsyncIterable<UIMessage>>
+  deleteChatConversation: (
+    chatConversationId: string,
+    chatAppId: string
+  ) => Promise<void>
+  fetchChatConversation: (
+    chatAppId: string,
+    chatConversationId: string
+  ) => Promise<ChatConversation>
+  fetchChatHistory: (chatAppId: string) => Promise<FetchAgentHistoryResponse>
+  fetchChatApp: (workspaceId?: string) => Promise<ChatApp | null>
+  setChatAppAgent: (chatAppId: string, agentId: string) => Promise<ChatApp>
+  createChatConversation: (
+    chat: CreateChatConversationRequest,
+    workspaceId?: string
+  ) => Promise<ChatConversation>
+  updateChatApp: (chatApp: UpdateChatAppRequest) => Promise<ChatApp>
+}
+
+const throwOnErrorChunk = () =>
+  new TransformStream<UIMessageChunk, UIMessageChunk>({
+    transform(chunk, controller) {
+      if (chunk.type === "error") {
+        throw new Error(chunk.errorText || "Agent action failed")
+      }
+      controller.enqueue(chunk)
+    },
+  })
+
+export const buildChatAppEndpoints = (
+  API: BaseAPIClient
+): ChatAppEndpoints => ({
+  streamChatConversation: async (chat, workspaceId) => {
+    if (!chat.chatAppId) {
+      throw new Error("chatAppId is required to stream a chat conversation")
+    }
+
+    const body: ChatAgentRequest = chat
+    const conversationId = chat._id || "new"
+
+    const response = await fetch(
+      `/api/chatapps/${chat.chatAppId}/conversations/${conversationId}/stream`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          [Header.APP_ID]: workspaceId,
+        },
+        body: JSON.stringify(body),
+        credentials: "same-origin",
+      }
+    )
+
+    if (!response.ok) {
+      const errorBody = await response.json()
+      throw new Error(
+        errorBody.message || `HTTP error! status: ${response.status}`
+      )
+    }
+
+    if (!response.body) {
+      throw new Error("Failed to get response body")
+    }
+
+    const chunkStream = response.body
+      .pipeThrough(new TextDecoderStream())
+      .pipeThrough(createSseToJsonTransformStream<UIMessageChunk>())
+      .pipeThrough(throwOnErrorChunk())
+
+    return readUIMessageStream({
+      stream: chunkStream,
+      terminateOnError: true,
+    })
+  },
+
+  deleteChatConversation: async (
+    chatConversationId: string,
+    chatAppId: string
+  ) => {
+    return await API.delete({
+      url: `/api/chatapps/${chatAppId}/conversations/${chatConversationId}`,
+    })
+  },
+
+  fetchChatConversation: async (
+    chatAppId: string,
+    chatConversationId: string
+  ) => {
+    return await API.get({
+      url: `/api/chatapps/${chatAppId}/conversations/${chatConversationId}`,
+    })
+  },
+
+  fetchChatHistory: async (chatAppId: string) => {
+    return await API.get({
+      url: `/api/chatapps/${chatAppId}/conversations`,
+    })
+  },
+
+  fetchChatApp: async (workspaceId?: string) => {
+    const url = "/api/chatapps"
+    const headers = workspaceId
+      ? {
+          [Header.APP_ID]: workspaceId,
+        }
+      : undefined
+    return await API.get({
+      url,
+      ...(headers && { headers }),
+    })
+  },
+
+  setChatAppAgent: async (chatAppId: string, agentId: string) => {
+    if (!chatAppId) {
+      throw new Error("chatAppId is required to set chat app agent")
+    }
+    if (!agentId) {
+      throw new Error("agentId is required to set chat app agent")
+    }
+    return await API.post({
+      url: `/api/chatapps/${chatAppId}/agent`,
+      body: { agentId } as any,
+    })
+  },
+
+  createChatConversation: async (
+    chat: CreateChatConversationRequest,
+    workspaceId?: string
+  ) => {
+    const resolvedWorkspaceId = workspaceId || API.getAppID()
+    const { chatAppId } = chat
+    if (!chatAppId) {
+      throw new Error("chatAppId is required to create a chat conversation")
+    }
+
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    }
+
+    if (resolvedWorkspaceId) {
+      headers[Header.APP_ID] = resolvedWorkspaceId
+    }
+
+    const response = await fetch(`/api/chatapps/${chatAppId}/conversations`, {
+      method: "POST",
+      headers,
+      credentials: "same-origin",
+      body: JSON.stringify(chat),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.json().catch(() => null)
+      throw new Error(
+        errorBody?.message || `HTTP error! status: ${response.status}`
+      )
+    }
+
+    return (await response.json()) as ChatConversation
+  },
+
+  updateChatApp: async (chatApp: UpdateChatAppRequest) => {
+    if (!chatApp._id) {
+      throw new Error("chatAppId is required to update a chat app")
+    }
+    return await API.put({
+      url: `/api/chatapps/${chatApp._id}`,
+      body: chatApp as any,
+    })
+  },
+})

package/src/api/index.ts

@@ -47,6 +47,7 @@ import { buildMigrationEndpoints } from "./migrations"
 import { buildRowActionEndpoints } from "./rowActions"
 import { buildOAuth2Endpoints } from "./oauth2"
 import { buildAgentEndpoints } from "./agents"
+import { buildChatAppEndpoints } from "./chatApps"
 import { buildFeatureFlagEndpoints } from "./features"
 import { buildNavigationEndpoints } from "./navigation"
 import { buildWorkspaceAppEndpoints } from "./workspaceApps"
@@ -313,6 +314,7 @@ export const createAPIClient = (config: APIClientConfig = {}): APIClient => {
     ...buildLogsEndpoints(API),
     ...buildMigrationEndpoints(API),
     ...buildAgentEndpoints(API),
+    ...buildChatAppEndpoints(API),
     ...buildFeatureFlagEndpoints(API),
     deployment: buildDeploymentEndpoints(API),
     viewV2: buildViewV2Endpoints(API),

package/src/api/types.ts

@@ -35,6 +35,7 @@ import { UserEndpoints } from "./user"
 import { ViewEndpoints } from "./views"
 import { ViewV2Endpoints } from "./viewsV2"
 import { AgentEndpoints } from "./agents"
+import { ChatAppEndpoints } from "./chatApps"
 import { NavigationEndpoints } from "./navigation"
 import { WorkspaceAppEndpoints } from "./workspaceApps"
 import { ResourceEndpoints } from "./resource"
@@ -113,6 +114,7 @@ export type APIError = {
 export type APIClient = BaseAPIClient &
   AIEndpoints &
   AgentEndpoints &
+  ChatAppEndpoints &
   AnalyticsEndpoints &
   AppEndpoints &
   AttachmentEndpoints &

package/src/components/Chatbox/index.svelte

@@ -1,6 +1,10 @@
 <script lang="ts">
   import { MarkdownViewer, notifications } from "@budibase/bbui"
-  import type { AgentChat } from "@budibase/types"
+  import type {
+    ChatConversation,
+    ChatConversationRequest,
+  } from "@budibase/types"
+  import { Header } from "@budibase/shared-core"
   import BBAI from "../../icons/BBAI.svelte"
   import { tick } from "svelte"
   import { onDestroy } from "svelte"
@@ -10,14 +14,21 @@
   import type { UIMessage } from "ai"
   import { v4 as uuidv4 } from "uuid"
 
-  export let API = createAPIClient()
-
   export let workspaceId: string
-  export let chat: AgentChat
+  export let API = createAPIClient({
+    attachHeaders: headers => {
+      if (workspaceId) {
+        headers[Header.APP_ID] = workspaceId
+      }
+    },
+  })
+  type ChatConversationLike = ChatConversation | ChatConversationRequest
+
+  export let chat: ChatConversationLike
   export let loading: boolean = false
 
   const dispatch = createEventDispatcher<{
-    chatSaved: { chatId?: string; chat: AgentChat }
+    chatSaved: { chatId?: string; chat: ChatConversationLike }
   }>()
 
   let inputValue = ""
@@ -25,12 +36,32 @@
   let observer: MutationObserver
   let textareaElement: HTMLTextAreaElement
   let lastFocusedChatId: string | undefined
-  let lastFocusedNewChat: AgentChat | undefined
+  let lastFocusedNewChat: ChatConversationLike | undefined
 
   $: if (chat?.messages?.length) {
     scrollToBottom()
   }
 
+  const ensureChatApp = async (): Promise<string | undefined> => {
+    if (chat?.chatAppId) {
+      return chat.chatAppId
+    }
+    try {
+      const chatApp = await API.fetchChatApp(workspaceId)
+      if (chatApp?._id) {
+        const baseChat = chat || { title: "", messages: [], chatAppId: "" }
+        chat = {
+          ...baseChat,
+          chatAppId: chatApp._id,
+        }
+        return chatApp._id
+      }
+    } catch (err) {
+      console.error(err)
+    }
+    return undefined
+  }
+
   async function scrollToBottom() {
     await tick()
     if (chatAreaElement) {
@@ -46,8 +77,41 @@
   }
 
   async function prompt() {
+    const resolvedChatAppId = await ensureChatApp()
+
     if (!chat) {
-      chat = { title: "", messages: [] }
+      chat = { title: "", messages: [], chatAppId: "" }
+    }
+
+    const chatAppId = chat.chatAppId || resolvedChatAppId
+
+    if (!chatAppId) {
+      notifications.error("Chat app could not be created")
+      return
+    }
+
+    if (!chat._id && (!chat.messages || chat.messages.length === 0)) {
+      try {
+        const newChat = await API.createChatConversation(
+          {
+            chatAppId,
+            title: chat.title,
+          },
+          workspaceId
+        )
+
+        chat = {
+          ...chat,
+          ...newChat,
+          chatAppId,
+        }
+      } catch (err: any) {
+        console.error(err)
+        notifications.error(
+          err?.message || "Could not start a new chat conversation"
+        )
+        return
+      }
     }
 
     const userMessage: UIMessage = {
@@ -56,8 +120,9 @@
       parts: [{ type: "text", text: inputValue }],
     }
 
-    const updatedChat: AgentChat = {
+    const updatedChat: ChatConversationLike = {
       ...chat,
+      chatAppId: chat.chatAppId,
       messages: [...chat.messages, userMessage],
     }
 
@@ -68,16 +133,41 @@
     loading = true
 
     try {
-      const messageStream = await API.agentChatStream(updatedChat, workspaceId)
+      const messageStream = await API.streamChatConversation(
+        updatedChat,
+        workspaceId
+      )
+
+      let streamedMessages: UIMessage[] = [...updatedChat.messages]
 
       for await (const message of messageStream) {
+        streamedMessages = [...streamedMessages, message]
         chat = {
           ...updatedChat,
-          messages: [...updatedChat.messages, message],
+          messages: streamedMessages,
         }
         scrollToBottom()
       }
 
+      // When a chat is created for the first time the server generates the ID.
+      // If we don't have it locally yet, retrieve the saved conversation so
+      // subsequent prompts append to the same document instead of creating a new one.
+      if (!chat._id && chat.chatAppId) {
+        try {
+          const history = await API.fetchChatHistory(chat.chatAppId)
+          const lastMessageId = chat.messages[chat.messages.length - 1]?.id
+          const savedConversation =
+            history?.find(convo =>
+              convo.messages.some(message => message.id === lastMessageId)
+            ) || history?.[0]
+          if (savedConversation) {
+            chat = savedConversation
+          }
+        } catch (historyError) {
+          console.error(historyError)
+        }
+      }
+
       loading = false
       dispatch("chatSaved", { chatId: chat._id, chat })
     } catch (err: any) {
@@ -93,6 +183,8 @@
   }
 
   onMount(async () => {
+    await ensureChatApp()
+
     // Ensure we always autoscroll to reveal new messages
     observer = new MutationObserver(async () => {
       await tick()