@fluxbase/sdk 2026.1.14-rc.3 → 2026.1.14-rc.4

package/dist/index.cjs

@@ -9602,23 +9602,50 @@ var FluxbaseAIChat = class {
    * Start a new chat session with a chatbot
    *
    * @param chatbot - Chatbot name
-   * @param namespace - Optional namespace (defaults to 'default')
+   * @param namespace - Optional namespace. If not provided and a lookup function is available,
+   *                    performs smart resolution:
+   *                    - If exactly one chatbot with this name exists, uses it
+   *                    - If multiple exist, tries "default" namespace
+   *                    - If ambiguous and not in default, throws error with available namespaces
+   *                    If no lookup function, falls back to "default" namespace.
    * @param conversationId - Optional conversation ID to resume
    * @param impersonateUserId - Optional user ID to impersonate (admin only)
    * @returns Promise resolving to conversation ID
    */
   async startChat(chatbot, namespace, conversationId, impersonateUserId) {
-    return new Promise((resolve, reject) => {
-      if (!this.isConnected()) {
-        reject(new Error("Not connected to AI chat"));
-        return;
+    if (!this.isConnected()) {
+      throw new Error("Not connected to AI chat");
+    }
+    let resolvedNamespace = namespace;
+    if (!resolvedNamespace && this.options._lookupChatbot) {
+      const { data, error } = await this.options._lookupChatbot(chatbot);
+      if (error) {
+        throw new Error(`Failed to lookup chatbot: ${error.message}`);
+      }
+      if (!data) {
+        throw new Error(`Chatbot '${chatbot}' not found`);
+      }
+      if (data.ambiguous) {
+        throw new Error(
+          `Chatbot '${chatbot}' exists in multiple namespaces: ${data.namespaces?.join(", ")}. Please specify the namespace explicitly.`
+        );
       }
+      if (data.chatbot) {
+        resolvedNamespace = data.chatbot.namespace;
+      } else if (data.error) {
+        throw new Error(data.error);
+      }
+    }
+    if (!resolvedNamespace) {
+      resolvedNamespace = "default";
+    }
+    return new Promise((resolve, reject) => {
       this.pendingStartResolve = resolve;
       this.pendingStartReject = reject;
       const message = {
         type: "start_chat",
         chatbot,
-        namespace: namespace || "default",
+        namespace: resolvedNamespace,
         conversation_id: conversationId,
         impersonate_user_id: impersonateUserId
       };
@@ -9690,13 +9717,20 @@ var FluxbaseAIChat = class {
         case "content":
           if (message.conversation_id && message.delta) {
             const current = this.accumulatedContent.get(message.conversation_id) || "";
-            this.accumulatedContent.set(message.conversation_id, current + message.delta);
+            this.accumulatedContent.set(
+              message.conversation_id,
+              current + message.delta
+            );
             this.options.onContent?.(message.delta, message.conversation_id);
           }
           break;
         case "progress":
           if (message.step && message.message && message.conversation_id) {
-            this.options.onProgress?.(message.step, message.message, message.conversation_id);
+            this.options.onProgress?.(
+              message.step,
+              message.message,
+              message.conversation_id
+            );
           }
           break;
         case "query_result":
@@ -9717,11 +9751,17 @@ var FluxbaseAIChat = class {
           break;
         case "error":
           if (this.pendingStartReject) {
-            this.pendingStartReject(new Error(message.error || "Unknown error"));
+            this.pendingStartReject(
+              new Error(message.error || "Unknown error")
+            );
             this.pendingStartResolve = null;
             this.pendingStartReject = null;
           }
-          this.options.onError?.(message.error || "Unknown error", message.code, message.conversation_id);
+          this.options.onError?.(
+            message.error || "Unknown error",
+            message.code,
+            message.conversation_id
+          );
           break;
       }
       this.emitEvent(event);
@@ -9771,9 +9811,7 @@ var FluxbaseAI = class {
    */
   async listChatbots() {
     try {
-      const response = await this.fetch.get(
-        "/api/v1/ai/chatbots"
-      );
+      const response = await this.fetch.get("/api/v1/ai/chatbots");
       return { data: response.chatbots || [], error: null };
     } catch (error) {
       return { data: null, error };
@@ -9787,7 +9825,41 @@ var FluxbaseAI = class {
    */
   async getChatbot(id) {
     try {
-      const data = await this.fetch.get(`/api/v1/ai/chatbots/${id}`);
+      const data = await this.fetch.get(
+        `/api/v1/ai/chatbots/${id}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Lookup a chatbot by name with smart namespace resolution
+   *
+   * Resolution logic:
+   * 1. If exactly one chatbot with this name exists -> returns it
+   * 2. If multiple exist -> tries "default" namespace first
+   * 3. If multiple exist and none in "default" -> returns ambiguous=true with namespaces list
+   *
+   * @param name - Chatbot name
+   * @returns Promise resolving to { data, error } tuple with lookup result
+   *
+   * @example
+   * ```typescript
+   * // Lookup chatbot by name
+   * const { data, error } = await ai.lookupChatbot('sql-assistant')
+   * if (data?.chatbot) {
+   *   console.log(`Found in namespace: ${data.chatbot.namespace}`)
+   * } else if (data?.ambiguous) {
+   *   console.log(`Chatbot exists in: ${data.namespaces?.join(', ')}`)
+   * }
+   * ```
+   */
+  async lookupChatbot(name) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/ai/chatbots/by-name/${encodeURIComponent(name)}`
+      );
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
@@ -9802,7 +9874,8 @@ var FluxbaseAI = class {
   createChat(options) {
     return new FluxbaseAIChat({
       ...options,
-      wsUrl: `${this.wsBaseUrl}/ai/ws`
+      wsUrl: `${this.wsBaseUrl}/ai/ws`,
+      _lookupChatbot: (name) => this.lookupChatbot(name)
     });
   }
   /**
@@ -9828,8 +9901,10 @@ var FluxbaseAI = class {
       const params = new URLSearchParams();
       if (options?.chatbot) params.set("chatbot", options.chatbot);
       if (options?.namespace) params.set("namespace", options.namespace);
-      if (options?.limit !== void 0) params.set("limit", String(options.limit));
-      if (options?.offset !== void 0) params.set("offset", String(options.offset));
+      if (options?.limit !== void 0)
+        params.set("limit", String(options.limit));
+      if (options?.offset !== void 0)
+        params.set("offset", String(options.offset));
       const queryString = params.toString();
       const path = `/api/v1/ai/conversations${queryString ? `?${queryString}` : ""}`;
       const response = await this.fetch.get(path);