@fluxbase/sdk 0.0.1-rc.46 → 0.0.1-rc.50

package/dist/index.cjs

@@ -155,6 +155,12 @@ var FluxbaseFetch = class {
   async getWithHeaders(path, options = {}) {
     return this.requestWithHeaders(path, { ...options, method: "GET" });
   }
+  /**
+   * POST request that returns response with headers (for POST-based queries with count)
+   */
+  async postWithHeaders(path, body, options = {}) {
+    return this.requestWithHeaders(path, { ...options, method: "POST", body });
+  }
   /**
    * Make an HTTP request and return response with headers
    */
@@ -262,6 +268,44 @@ var FluxbaseFetch = class {
     });
     return response.headers;
   }
+  /**
+   * GET request that returns response as Blob (for file downloads)
+   */
+  async getBlob(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = { ...this.defaultHeaders, ...options.headers };
+    delete headers["Content-Type"];
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeout ?? this.timeout);
+    if (this.debug) {
+      console.log(`[Fluxbase SDK] GET (blob) ${url}`);
+    }
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const error = new Error(response.statusText);
+        error.status = response.status;
+        throw error;
+      }
+      return await response.blob();
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error) {
+        if (err.name === "AbortError") {
+          const timeoutError = new Error("Request timeout");
+          timeoutError.status = 408;
+          throw timeoutError;
+        }
+        throw err;
+      }
+      throw new Error("Unknown error occurred");
+    }
+  }
 };
 
 // src/utils/error-handling.ts
@@ -1112,8 +1156,10 @@ var RealtimeChannel = class {
     this.callbacks = /* @__PURE__ */ new Map();
     this.presenceCallbacks = /* @__PURE__ */ new Map();
     this.broadcastCallbacks = /* @__PURE__ */ new Map();
+    this.executionLogCallbacks = /* @__PURE__ */ new Set();
     this.subscriptionConfig = null;
     this.subscriptionId = null;
+    this.executionLogConfig = null;
     this._presenceState = {};
     this.myPresenceKey = null;
     this.reconnectAttempts = 0;
@@ -1162,6 +1208,11 @@ var RealtimeChannel = class {
         this.presenceCallbacks.set(config.event, /* @__PURE__ */ new Set());
       }
       this.presenceCallbacks.get(config.event).add(actualCallback);
+    } else if (event === "execution_log" && typeof configOrCallback !== "function") {
+      const config = configOrCallback;
+      this.executionLogConfig = config;
+      const actualCallback = callback;
+      this.executionLogCallbacks.add(actualCallback);
     } else {
       const actualEvent = event;
       const actualCallback = configOrCallback;
@@ -1442,14 +1493,26 @@ var RealtimeChannel = class {
     this.ws.onopen = () => {
       console.log("[Fluxbase Realtime] Connected");
       this.reconnectAttempts = 0;
-      const subscribeMessage = {
-        type: "subscribe",
-        channel: this.channelName
-      };
-      if (this.subscriptionConfig) {
-        subscribeMessage.config = this.subscriptionConfig;
+      if (this.executionLogConfig) {
+        const logSubscribeMessage = {
+          type: "subscribe_logs",
+          channel: this.channelName,
+          config: {
+            execution_id: this.executionLogConfig.execution_id,
+            type: this.executionLogConfig.type || "function"
+          }
+        };
+        this.sendMessage(logSubscribeMessage);
+      } else {
+        const subscribeMessage = {
+          type: "subscribe",
+          channel: this.channelName
+        };
+        if (this.subscriptionConfig) {
+          subscribeMessage.config = this.subscriptionConfig;
+        }
+        this.sendMessage(subscribeMessage);
       }
-      this.sendMessage(subscribeMessage);
       this.startHeartbeat();
     };
     this.ws.onmessage = (event) => {
@@ -1559,8 +1622,25 @@ var RealtimeChannel = class {
           this.handlePostgresChanges(message.payload);
         }
         break;
+      case "execution_log":
+        if (message.payload) {
+          this.handleExecutionLog(message.payload);
+        }
+        break;
     }
   }
+  /**
+   * Internal: Handle execution log message
+   */
+  handleExecutionLog(log) {
+    this.executionLogCallbacks.forEach((callback) => {
+      try {
+        callback(log);
+      } catch (err) {
+        console.error("[Fluxbase Realtime] Error in execution log callback:", err);
+      }
+    });
+  }
   /**
    * Internal: Handle broadcast message
    */
@@ -1804,6 +1884,98 @@ var FluxbaseRealtime = class {
       channel.updateToken(token);
     });
   }
+  /**
+   * Create an execution log subscription channel
+   *
+   * This provides a cleaner API for subscribing to execution logs
+   * (functions, jobs, or RPC procedures).
+   *
+   * @param executionId - The execution ID to subscribe to
+   * @param type - The type of execution ('function', 'job', 'rpc')
+   * @returns ExecutionLogsChannel instance with fluent API
+   *
+   * @example
+   * ```typescript
+   * const channel = client.realtime.executionLogs('exec-123', 'function')
+   *   .onLog((log) => {
+   *     console.log(`[${log.level}] ${log.message}`)
+   *   })
+   *   .subscribe()
+   * ```
+   */
+  executionLogs(executionId, type = "function") {
+    return new ExecutionLogsChannel(this.url, executionId, type, this.token, this.tokenRefreshCallback);
+  }
+};
+var ExecutionLogsChannel = class {
+  constructor(url, executionId, type, token, tokenRefreshCallback) {
+    this.logCallbacks = [];
+    this.executionId = executionId;
+    this.executionType = type;
+    const channelName = `execution:${executionId}`;
+    this.channel = new RealtimeChannel(url, channelName, token);
+    if (tokenRefreshCallback) {
+      this.channel.setTokenRefreshCallback(tokenRefreshCallback);
+    }
+  }
+  /**
+   * Register a callback for log events
+   *
+   * @param callback - Function to call when log entries are received
+   * @returns This channel for chaining
+   *
+   * @example
+   * ```typescript
+   * channel.onLog((log) => {
+   *   console.log(`[${log.level}] Line ${log.line_number}: ${log.message}`)
+   * })
+   * ```
+   */
+  onLog(callback) {
+    this.logCallbacks.push(callback);
+    return this;
+  }
+  /**
+   * Subscribe to execution logs
+   *
+   * @param callback - Optional status callback
+   * @returns Promise that resolves when subscribed
+   *
+   * @example
+   * ```typescript
+   * await channel.subscribe()
+   * ```
+   */
+  subscribe(callback) {
+    this.channel.on(
+      "execution_log",
+      { execution_id: this.executionId, type: this.executionType },
+      (log) => {
+        this.logCallbacks.forEach((cb) => {
+          try {
+            cb(log);
+          } catch (err) {
+            console.error("[Fluxbase ExecutionLogs] Error in log callback:", err);
+          }
+        });
+      }
+    );
+    this.channel.subscribe(callback);
+    return this;
+  }
+  /**
+   * Unsubscribe from execution logs
+   *
+   * @returns Promise resolving to status
+   *
+   * @example
+   * ```typescript
+   * await channel.unsubscribe()
+   * ```
+   */
+  async unsubscribe() {
+    return this.channel.unsubscribe();
+  }
 };
 
 // src/storage.ts
@@ -1919,6 +2091,127 @@ var StorageBucket = class {
       xhr.send(formData);
     });
   }
+  /**
+   * Upload a file using streaming for reduced memory usage.
+   * This method bypasses FormData buffering and streams data directly to the server.
+   * Ideal for large files where memory efficiency is important.
+   *
+   * @param path - The path/key for the file
+   * @param stream - ReadableStream of the file data
+   * @param size - The size of the file in bytes (required for Content-Length header)
+   * @param options - Upload options
+   *
+   * @example
+   * ```typescript
+   * // Upload from a File's stream
+   * const file = new File([...], 'large-video.mp4');
+   * const { data, error } = await storage
+   *   .from('videos')
+   *   .uploadStream('video.mp4', file.stream(), file.size, {
+   *     contentType: 'video/mp4',
+   *   });
+   *
+   * // Upload from a fetch response stream
+   * const response = await fetch('https://example.com/data.zip');
+   * const size = parseInt(response.headers.get('content-length') || '0');
+   * const { data, error } = await storage
+   *   .from('files')
+   *   .uploadStream('data.zip', response.body!, size, {
+   *     contentType: 'application/zip',
+   *   });
+   * ```
+   */
+  async uploadStream(path, stream, size, options) {
+    try {
+      if (size <= 0) {
+        return { data: null, error: new Error("size must be a positive number") };
+      }
+      const headers = {
+        ...this.fetch["defaultHeaders"],
+        "Content-Length": String(size)
+      };
+      if (options?.contentType) {
+        headers["X-Storage-Content-Type"] = options.contentType;
+      }
+      if (options?.cacheControl) {
+        headers["X-Storage-Cache-Control"] = options.cacheControl;
+      }
+      if (options?.metadata && Object.keys(options.metadata).length > 0) {
+        headers["X-Storage-Metadata"] = JSON.stringify(options.metadata);
+      }
+      let bodyStream = stream;
+      if (options?.onUploadProgress) {
+        let uploadedBytes = 0;
+        const progressCallback = options.onUploadProgress;
+        const totalSize = size;
+        const transformStream = new TransformStream({
+          transform(chunk, controller) {
+            uploadedBytes += chunk.byteLength;
+            const percentage = Math.round(uploadedBytes / totalSize * 100);
+            progressCallback({
+              loaded: uploadedBytes,
+              total: totalSize,
+              percentage
+            });
+            controller.enqueue(chunk);
+          }
+        });
+        bodyStream = stream.pipeThrough(transformStream);
+      }
+      const response = await fetch(
+        `${this.fetch["baseUrl"]}/api/v1/storage/${this.bucketName}/stream/${path}`,
+        {
+          method: "POST",
+          headers,
+          body: bodyStream,
+          signal: options?.signal,
+          // @ts-expect-error - duplex is not yet in TypeScript's RequestInit type
+          duplex: "half"
+        }
+      );
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({ error: response.statusText }));
+        throw new Error(errorData.error || `Upload failed: ${response.statusText}`);
+      }
+      const result = await response.json();
+      return {
+        data: {
+          id: result.key || path,
+          path,
+          fullPath: `${this.bucketName}/${path}`
+        },
+        error: null
+      };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Upload a large file using streaming for reduced memory usage.
+   * This is a convenience method that converts a File or Blob to a stream.
+   *
+   * @param path - The path/key for the file
+   * @param file - The File or Blob to upload
+   * @param options - Upload options
+   *
+   * @example
+   * ```typescript
+   * const file = new File([...], 'large-video.mp4');
+   * const { data, error } = await storage
+   *   .from('videos')
+   *   .uploadLargeFile('video.mp4', file, {
+   *     contentType: 'video/mp4',
+   *     onUploadProgress: (p) => console.log(`${p.percentage}% complete`),
+   *   });
+   * ```
+   */
+  async uploadLargeFile(path, file, options) {
+    const opts = {
+      ...options,
+      contentType: options?.contentType || file.type || "application/octet-stream"
+    };
+    return this.uploadStream(path, file.stream(), file.size, opts);
+  }
   async download(path, options) {
     try {
       const controller = new AbortController();
@@ -2146,59 +2439,335 @@ var StorageBucket = class {
     }
   }
   /**
-   * List files in the bucket
-   * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
-   * @param pathOrOptions - The folder path or list options
-   * @param maybeOptions - List options when first param is a path
+   * Upload a large file with resumable chunked uploads.
+   *
+   * Features:
+   * - Uploads file in chunks for reliability
+   * - Automatically retries failed chunks with exponential backoff
+   * - Reports progress via callback with chunk-level granularity
+   * - Can resume interrupted uploads using session ID
+   *
+   * @param path - The file path within the bucket
+   * @param file - The File or Blob to upload
+   * @param options - Upload options including chunk size, retries, and progress callback
+   * @returns Upload result with file info
+   *
+   * @example
+   * const { data, error } = await storage.from('uploads').uploadResumable('large.zip', file, {
+   *   chunkSize: 5 * 1024 * 1024, // 5MB chunks
+   *   maxRetries: 3,
+   *   onProgress: (p) => {
+   *     console.log(`${p.percentage}% (chunk ${p.currentChunk}/${p.totalChunks})`);
+   *     console.log(`Speed: ${(p.bytesPerSecond / 1024 / 1024).toFixed(2)} MB/s`);
+   *     console.log(`Session ID (for resume): ${p.sessionId}`);
+   *   }
+   * });
+   *
+   * // To resume an interrupted upload:
+   * const { data, error } = await storage.from('uploads').uploadResumable('large.zip', file, {
+   *   resumeSessionId: 'previous-session-id',
+   * });
    */
-  async list(pathOrOptions, maybeOptions) {
+  async uploadResumable(path, file, options) {
     try {
-      const params = new URLSearchParams();
-      let prefix;
-      let options;
-      if (typeof pathOrOptions === "string") {
-        prefix = pathOrOptions;
-        options = maybeOptions;
+      const chunkSize = options?.chunkSize ?? 5 * 1024 * 1024;
+      const maxRetries = options?.maxRetries ?? 3;
+      const retryDelayMs = options?.retryDelayMs ?? 1e3;
+      const chunkTimeout = options?.chunkTimeout ?? 6e4;
+      const totalSize = file.size;
+      const totalChunks = Math.ceil(totalSize / chunkSize);
+      if (options?.signal?.aborted) {
+        return { data: null, error: new Error("Upload aborted") };
+      }
+      const baseUrl = this.fetch["baseUrl"];
+      const headers = this.fetch["defaultHeaders"];
+      let sessionId = options?.resumeSessionId;
+      let session;
+      let completedChunks = [];
+      if (!sessionId) {
+        const initResponse = await fetch(
+          `${baseUrl}/api/v1/storage/${this.bucketName}/chunked/init`,
+          {
+            method: "POST",
+            headers: {
+              ...headers,
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              path,
+              total_size: totalSize,
+              chunk_size: chunkSize,
+              content_type: options?.contentType || file.type || "application/octet-stream",
+              metadata: options?.metadata,
+              cache_control: options?.cacheControl
+            }),
+            signal: options?.signal
+          }
+        );
+        if (!initResponse.ok) {
+          const errorData = await initResponse.json().catch(() => ({}));
+          throw new Error(
+            errorData.error || `Failed to initialize upload: ${initResponse.statusText}`
+          );
+        }
+        const initData = await initResponse.json();
+        session = {
+          sessionId: initData.session_id,
+          bucket: initData.bucket,
+          path: initData.path,
+          totalSize: initData.total_size,
+          chunkSize: initData.chunk_size,
+          totalChunks: initData.total_chunks,
+          completedChunks: initData.completed_chunks || [],
+          status: initData.status,
+          expiresAt: initData.expires_at,
+          createdAt: initData.created_at
+        };
+        sessionId = session.sessionId;
       } else {
-        options = pathOrOptions;
-        prefix = options?.prefix;
+        const statusResponse = await fetch(
+          `${baseUrl}/api/v1/storage/${this.bucketName}/chunked/${sessionId}/status`,
+          {
+            method: "GET",
+            headers,
+            signal: options?.signal
+          }
+        );
+        if (!statusResponse.ok) {
+          const errorData = await statusResponse.json().catch(() => ({}));
+          throw new Error(
+            errorData.error || `Failed to get session status: ${statusResponse.statusText}`
+          );
+        }
+        const statusData = await statusResponse.json();
+        session = statusData.session;
+        completedChunks = session.completedChunks || [];
       }
-      if (prefix) {
-        params.set("prefix", prefix);
+      let uploadedBytes = 0;
+      for (const chunkIdx of completedChunks) {
+        const chunkStart = chunkIdx * chunkSize;
+        const chunkEnd = Math.min(chunkStart + chunkSize, totalSize);
+        uploadedBytes += chunkEnd - chunkStart;
       }
-      if (options?.limit) {
-        params.set("limit", String(options.limit));
+      let lastProgressTime = Date.now();
+      let lastProgressBytes = uploadedBytes;
+      for (let chunkIndex = 0; chunkIndex < totalChunks; chunkIndex++) {
+        if (options?.signal?.aborted) {
+          return { data: null, error: new Error("Upload aborted") };
+        }
+        if (completedChunks.includes(chunkIndex)) {
+          continue;
+        }
+        const start = chunkIndex * chunkSize;
+        const end = Math.min(start + chunkSize, totalSize);
+        const chunk = file.slice(start, end);
+        const chunkArrayBuffer = await chunk.arrayBuffer();
+        let retryCount = 0;
+        let chunkUploaded = false;
+        while (retryCount <= maxRetries && !chunkUploaded) {
+          try {
+            if (options?.signal?.aborted) {
+              return { data: null, error: new Error("Upload aborted") };
+            }
+            const chunkController = new AbortController();
+            const timeoutId = setTimeout(() => chunkController.abort(), chunkTimeout);
+            if (options?.signal) {
+              options.signal.addEventListener(
+                "abort",
+                () => chunkController.abort(),
+                { once: true }
+              );
+            }
+            const chunkResponse = await fetch(
+              `${baseUrl}/api/v1/storage/${this.bucketName}/chunked/${sessionId}/${chunkIndex}`,
+              {
+                method: "PUT",
+                headers: {
+                  ...headers,
+                  "Content-Type": "application/octet-stream",
+                  "Content-Length": String(chunkArrayBuffer.byteLength)
+                },
+                body: chunkArrayBuffer,
+                signal: chunkController.signal
+              }
+            );
+            clearTimeout(timeoutId);
+            if (!chunkResponse.ok) {
+              const errorData = await chunkResponse.json().catch(() => ({}));
+              throw new Error(
+                errorData.error || `Chunk upload failed: ${chunkResponse.statusText}`
+              );
+            }
+            chunkUploaded = true;
+          } catch (err) {
+            if (options?.signal?.aborted) {
+              return { data: null, error: new Error("Upload aborted") };
+            }
+            retryCount++;
+            if (retryCount > maxRetries) {
+              throw new Error(
+                `Failed to upload chunk ${chunkIndex} after ${maxRetries} retries: ${err.message}`
+              );
+            }
+            const delay = retryDelayMs * Math.pow(2, retryCount - 1);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+          }
+        }
+        uploadedBytes += end - start;
+        if (options?.onProgress) {
+          const now = Date.now();
+          const elapsed = (now - lastProgressTime) / 1e3;
+          const bytesPerSecond = elapsed > 0 ? (uploadedBytes - lastProgressBytes) / elapsed : 0;
+          lastProgressTime = now;
+          lastProgressBytes = uploadedBytes;
+          options.onProgress({
+            loaded: uploadedBytes,
+            total: totalSize,
+            percentage: Math.round(uploadedBytes / totalSize * 100),
+            currentChunk: chunkIndex + 1,
+            totalChunks,
+            bytesPerSecond,
+            sessionId
+          });
+        }
       }
-      if (options?.offset) {
-        params.set("offset", String(options.offset));
+      const completeResponse = await fetch(
+        `${baseUrl}/api/v1/storage/${this.bucketName}/chunked/${sessionId}/complete`,
+        {
+          method: "POST",
+          headers,
+          signal: options?.signal
+        }
+      );
+      if (!completeResponse.ok) {
+        const errorData = await completeResponse.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `Failed to complete upload: ${completeResponse.statusText}`
+        );
       }
-      const queryString = params.toString();
-      const path = `/api/v1/storage/${this.bucketName}${queryString ? `?${queryString}` : ""}`;
-      const response = await this.fetch.get(path);
-      const files = (response.files || []).map((file) => ({
-        name: file.key || file.name,
-        id: file.id,
-        bucket_id: file.bucket || this.bucketName,
-        created_at: file.last_modified || file.created_at,
-        updated_at: file.updated_at,
-        last_accessed_at: file.last_accessed_at,
-        metadata: file.metadata
-      }));
-      return { data: files, error: null };
+      const result = await completeResponse.json();
+      return {
+        data: {
+          id: result.id,
+          path: result.path,
+          fullPath: result.full_path
+        },
+        error: null
+      };
     } catch (error) {
       return { data: null, error };
     }
   }
   /**
-   * Remove files from the bucket
-   * @param paths - Array of file paths to remove
+   * Abort an in-progress resumable upload
+   * @param sessionId - The upload session ID to abort
    */
-  async remove(paths) {
+  async abortResumableUpload(sessionId) {
     try {
-      const removedFiles = [];
-      for (const path of paths) {
-        await this.fetch.delete(`/api/v1/storage/${this.bucketName}/${path}`);
-        removedFiles.push({
+      const baseUrl = this.fetch["baseUrl"];
+      const headers = this.fetch["defaultHeaders"];
+      const response = await fetch(
+        `${baseUrl}/api/v1/storage/${this.bucketName}/chunked/${sessionId}`,
+        {
+          method: "DELETE",
+          headers
+        }
+      );
+      if (!response.ok && response.status !== 204) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `Failed to abort upload: ${response.statusText}`
+        );
+      }
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  /**
+   * Get the status of a resumable upload session
+   * @param sessionId - The upload session ID to check
+   */
+  async getResumableUploadStatus(sessionId) {
+    try {
+      const baseUrl = this.fetch["baseUrl"];
+      const headers = this.fetch["defaultHeaders"];
+      const response = await fetch(
+        `${baseUrl}/api/v1/storage/${this.bucketName}/chunked/${sessionId}/status`,
+        {
+          method: "GET",
+          headers
+        }
+      );
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `Failed to get upload status: ${response.statusText}`
+        );
+      }
+      const data = await response.json();
+      return {
+        data: data.session,
+        error: null
+      };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List files in the bucket
+   * Supports both Supabase-style list(path, options) and Fluxbase-style list(options)
+   * @param pathOrOptions - The folder path or list options
+   * @param maybeOptions - List options when first param is a path
+   */
+  async list(pathOrOptions, maybeOptions) {
+    try {
+      const params = new URLSearchParams();
+      let prefix;
+      let options;
+      if (typeof pathOrOptions === "string") {
+        prefix = pathOrOptions;
+        options = maybeOptions;
+      } else {
+        options = pathOrOptions;
+        prefix = options?.prefix;
+      }
+      if (prefix) {
+        params.set("prefix", prefix);
+      }
+      if (options?.limit) {
+        params.set("limit", String(options.limit));
+      }
+      if (options?.offset) {
+        params.set("offset", String(options.offset));
+      }
+      const queryString = params.toString();
+      const path = `/api/v1/storage/${this.bucketName}${queryString ? `?${queryString}` : ""}`;
+      const response = await this.fetch.get(path);
+      const files = (response.files || []).map((file) => ({
+        name: file.key || file.name,
+        id: file.id,
+        bucket_id: file.bucket || this.bucketName,
+        created_at: file.last_modified || file.created_at,
+        updated_at: file.updated_at,
+        last_accessed_at: file.last_accessed_at,
+        metadata: file.metadata
+      }));
+      return { data: files, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Remove files from the bucket
+   * @param paths - Array of file paths to remove
+   */
+  async remove(paths) {
+    try {
+      const removedFiles = [];
+      for (const path of paths) {
+        await this.fetch.delete(`/api/v1/storage/${this.bucketName}/${path}`);
+        removedFiles.push({
           name: path,
           bucket_id: this.bucketName
         });
@@ -2550,7 +3119,7 @@ var FluxbaseJobs = class {
    *
    * @param jobName - Name of the job function to execute
    * @param payload - Job input data
-   * @param options - Additional options (priority, namespace, scheduled time)
+   * @param options - Additional options (priority, namespace, scheduled time, onBehalfOf)
    * @returns Promise resolving to { data, error } tuple with submitted job details
    *
    * @example
@@ -2576,6 +3145,14 @@ var FluxbaseJobs = class {
    * const { data } = await client.jobs.submit('scheduled-task', payload, {
    *   scheduled: '2025-01-01T00:00:00Z'
    * })
+   *
+   * // Submit on behalf of a user (service_role only)
+   * const { data } = await serviceClient.jobs.submit('user-task', payload, {
+   *   onBehalfOf: {
+   *     user_id: 'user-uuid',
+   *     user_email: 'user@example.com'
+   *   }
+   * })
    * ```
    */
   async submit(jobName, payload, options) {
@@ -2583,7 +3160,10 @@ var FluxbaseJobs = class {
       const request = {
         job_name: jobName,
         payload,
-        ...options
+        priority: options?.priority,
+        namespace: options?.namespace,
+        scheduled: options?.scheduled,
+        on_behalf_of: options?.onBehalfOf
       };
       const data = await this.fetch.post("/api/v1/jobs/submit", request);
       return { data, error: null };
@@ -2705,6 +3285,210 @@ var FluxbaseJobs = class {
       return { data: null, error };
     }
   }
+  /**
+   * Get execution logs for a job
+   *
+   * Returns logs for the specified job. Only returns logs for jobs
+   * owned by the authenticated user (unless using service_role).
+   *
+   * @param jobId - Job ID
+   * @param afterLine - Optional line number to get logs after (for polling/streaming)
+   * @returns Promise resolving to { data, error } tuple with execution logs
+   *
+   * @example
+   * ```typescript
+   * // Get all logs for a job
+   * const { data: logs, error } = await client.jobs.getLogs('550e8400-e29b-41d4-a716-446655440000')
+   *
+   * if (logs) {
+   *   for (const log of logs) {
+   *     console.log(`[${log.level}] ${log.message}`)
+   *   }
+   * }
+   *
+   * // Backfill + stream pattern
+   * const { data: logs } = await client.jobs.getLogs(jobId)
+   * let lastLine = Math.max(...(logs?.map(l => l.line_number) ?? []), 0)
+   *
+   * const channel = client.realtime
+   *   .executionLogs(jobId, 'job')
+   *   .onLog((log) => {
+   *     if (log.line_number > lastLine) {
+   *       displayLog(log)
+   *       lastLine = log.line_number
+   *     }
+   *   })
+   *   .subscribe()
+   * ```
+   */
+  async getLogs(jobId, afterLine) {
+    try {
+      const params = afterLine !== void 0 ? `?after_line=${afterLine}` : "";
+      const response = await this.fetch.get(
+        `/api/v1/jobs/${jobId}/logs${params}`
+      );
+      return { data: response.logs || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/rpc.ts
+var FluxbaseRPC = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * List available RPC procedures (public, enabled)
+   *
+   * @param namespace - Optional namespace filter
+   * @returns Promise resolving to { data, error } tuple with array of procedure summaries
+   */
+  async list(namespace) {
+    try {
+      const params = namespace ? `?namespace=${encodeURIComponent(namespace)}` : "";
+      const response = await this.fetch.get(
+        `/api/v1/rpc/procedures${params}`
+      );
+      return { data: response.procedures || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Invoke an RPC procedure
+   *
+   * @param name - Procedure name
+   * @param params - Optional parameters to pass to the procedure
+   * @param options - Optional invocation options
+   * @returns Promise resolving to { data, error } tuple with invocation response
+   *
+   * @example
+   * ```typescript
+   * // Synchronous invocation
+   * const { data, error } = await fluxbase.rpc.invoke('get-user-orders', {
+   *   user_id: '123',
+   *   limit: 10
+   * });
+   * console.log(data.result); // Query results
+   *
+   * // Asynchronous invocation
+   * const { data: asyncData } = await fluxbase.rpc.invoke('generate-report', {
+   *   year: 2024
+   * }, { async: true });
+   * console.log(asyncData.execution_id); // Use to poll status
+   * ```
+   */
+  async invoke(name, params, options) {
+    try {
+      const namespace = options?.namespace || "default";
+      const response = await this.fetch.post(
+        `/api/v1/rpc/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`,
+        {
+          params,
+          async: options?.async
+        }
+      );
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get execution status (for async invocations or checking history)
+   *
+   * @param executionId - The execution ID returned from async invoke
+   * @returns Promise resolving to { data, error } tuple with execution details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await fluxbase.rpc.getStatus('execution-uuid');
+   * if (data.status === 'completed') {
+   *   console.log('Result:', data.result);
+   * } else if (data.status === 'running') {
+   *   console.log('Still running...');
+   * }
+   * ```
+   */
+  async getStatus(executionId) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/rpc/executions/${encodeURIComponent(executionId)}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get execution logs (for debugging and monitoring)
+   *
+   * @param executionId - The execution ID
+   * @param afterLine - Optional line number to get logs after (for polling)
+   * @returns Promise resolving to { data, error } tuple with execution logs
+   *
+   * @example
+   * ```typescript
+   * const { data: logs } = await fluxbase.rpc.getLogs('execution-uuid');
+   * for (const log of logs) {
+   *   console.log(`[${log.level}] ${log.message}`);
+   * }
+   * ```
+   */
+  async getLogs(executionId, afterLine) {
+    try {
+      const params = afterLine !== void 0 ? `?after=${afterLine}` : "";
+      const response = await this.fetch.get(
+        `/api/v1/rpc/executions/${encodeURIComponent(executionId)}/logs${params}`
+      );
+      return { data: response.logs || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Poll for execution completion with exponential backoff
+   *
+   * @param executionId - The execution ID to poll
+   * @param options - Polling options
+   * @returns Promise resolving to final execution state
+   *
+   * @example
+   * ```typescript
+   * const { data: result } = await fluxbase.rpc.invoke('long-task', {}, { async: true });
+   * const { data: final } = await fluxbase.rpc.waitForCompletion(result.execution_id, {
+   *   maxWaitMs: 60000, // Wait up to 1 minute
+   *   onProgress: (exec) => console.log(`Status: ${exec.status}`)
+   * });
+   * console.log('Final result:', final.result);
+   * ```
+   */
+  async waitForCompletion(executionId, options) {
+    const maxWait = options?.maxWaitMs || 3e4;
+    const initialInterval = options?.initialIntervalMs || 500;
+    const maxInterval = options?.maxIntervalMs || 5e3;
+    const startTime = Date.now();
+    let interval = initialInterval;
+    while (Date.now() - startTime < maxWait) {
+      const { data: execution, error } = await this.getStatus(executionId);
+      if (error) {
+        return { data: null, error };
+      }
+      if (!execution) {
+        return { data: null, error: new Error("Execution not found") };
+      }
+      if (options?.onProgress) {
+        options.onProgress(execution);
+      }
+      if (execution.status === "completed" || execution.status === "failed" || execution.status === "cancelled" || execution.status === "timeout") {
+        return { data: execution, error: null };
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+      interval = Math.min(interval * 1.5, maxInterval);
+    }
+    return { data: null, error: new Error("Timeout waiting for execution to complete") };
+  }
 };
 
 // src/settings.ts
@@ -3270,11 +4054,13 @@ var AppSettingsManager = class {
    * ```
    */
   async setSetting(key, value, options) {
+    const wrappedValue = value !== null && typeof value === "object" && !Array.isArray(value) ? value : { value };
     try {
       return await this.fetch.put(
         `/api/v1/admin/settings/custom/${key}`,
         {
-          value,
+          value: wrappedValue,
+          value_type: options?.value_type || "json",
           description: options?.description,
           is_public: options?.is_public,
           is_secret: options?.is_secret
@@ -3286,7 +4072,7 @@ var AppSettingsManager = class {
           "/api/v1/admin/settings/custom",
           {
             key,
-            value,
+            value: wrappedValue,
             value_type: options?.value_type || "json",
             description: options?.description,
             is_public: options?.is_public ?? false,
@@ -4524,8 +5310,146 @@ var FluxbaseManagement = class {
   }
 };
 
+// src/bundling.ts
+var esbuild = null;
+var fs = null;
+async function loadEsbuild() {
+  if (esbuild) return true;
+  try {
+    esbuild = await import('esbuild');
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadFs() {
+  if (fs) return true;
+  try {
+    fs = await import('fs');
+    return true;
+  } catch {
+    return false;
+  }
+}
+var denoExternalPlugin = {
+  name: "deno-external",
+  setup(build) {
+    build.onResolve({ filter: /^npm:/ }, (args) => ({
+      path: args.path,
+      external: true
+    }));
+    build.onResolve({ filter: /^https?:\/\// }, (args) => ({
+      path: args.path,
+      external: true
+    }));
+    build.onResolve({ filter: /^jsr:/ }, (args) => ({
+      path: args.path,
+      external: true
+    }));
+  }
+};
+async function loadImportMap(denoJsonPath) {
+  const hasFs = await loadFs();
+  if (!hasFs || !fs) {
+    console.warn("fs module not available, cannot load import map");
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(denoJsonPath, "utf-8");
+    const config = JSON.parse(content);
+    return config.imports || null;
+  } catch (error) {
+    console.warn(`Failed to load import map from ${denoJsonPath}:`, error);
+    return null;
+  }
+}
+async function bundleCode(options) {
+  const hasEsbuild = await loadEsbuild();
+  if (!hasEsbuild || !esbuild) {
+    throw new Error(
+      "esbuild is required for bundling. Install it with: npm install esbuild"
+    );
+  }
+  const externals = [...options.external ?? []];
+  const alias = {};
+  if (options.importMap) {
+    for (const [key, value] of Object.entries(options.importMap)) {
+      if (value.startsWith("npm:")) {
+        externals.push(key);
+      } else if (value.startsWith("https://") || value.startsWith("http://")) {
+        externals.push(key);
+      } else if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) {
+        alias[key] = value;
+      } else {
+        externals.push(key);
+      }
+    }
+  }
+  const denoPlugin = {
+    name: "deno-external",
+    setup(build) {
+      build.onResolve({ filter: /^npm:/ }, (args) => ({
+        path: args.path,
+        external: true
+      }));
+      build.onResolve({ filter: /^https?:\/\// }, (args) => ({
+        path: args.path,
+        external: true
+      }));
+      build.onResolve({ filter: /^jsr:/ }, (args) => ({
+        path: args.path,
+        external: true
+      }));
+    }
+  };
+  const resolveDir = options.baseDir || process.cwd?.() || "/";
+  const buildOptions = {
+    stdin: {
+      contents: options.code,
+      loader: "ts",
+      resolveDir
+    },
+    // Set absWorkingDir for consistent path resolution
+    absWorkingDir: resolveDir,
+    bundle: true,
+    write: false,
+    format: "esm",
+    // Use 'node' platform for better node_modules resolution (Deno supports Node APIs)
+    platform: "node",
+    target: "esnext",
+    minify: options.minify ?? false,
+    sourcemap: options.sourcemap ? "inline" : false,
+    external: externals,
+    plugins: [denoPlugin],
+    // Preserve handler export
+    treeShaking: true,
+    // Resolve .ts, .js, .mjs extensions
+    resolveExtensions: [".ts", ".tsx", ".js", ".mjs", ".json"],
+    // ESM conditions for better module resolution
+    conditions: ["import", "module"]
+  };
+  if (Object.keys(alias).length > 0) {
+    buildOptions.alias = alias;
+  }
+  if (options.nodePaths && options.nodePaths.length > 0) {
+    buildOptions.nodePaths = options.nodePaths;
+  }
+  if (options.define) {
+    buildOptions.define = options.define;
+  }
+  const result = await esbuild.build(buildOptions);
+  const output = result.outputFiles?.[0];
+  if (!output) {
+    throw new Error("Bundling failed: no output generated");
+  }
+  return {
+    code: output.text,
+    sourceMap: options.sourcemap ? output.text : void 0
+  };
+}
+
 // src/admin-functions.ts
-var FluxbaseAdminFunctions = class {
+var FluxbaseAdminFunctions = class _FluxbaseAdminFunctions {
   constructor(fetch2) {
     this.fetch = fetch2;
   }
@@ -4762,34 +5686,139 @@ var FluxbaseAdminFunctions = class {
       return { data: null, error };
     }
   }
-};
-
-// src/admin-migrations.ts
-var FluxbaseAdminMigrations = class {
-  constructor(fetch2) {
-    this.localMigrations = /* @__PURE__ */ new Map();
-    this.fetch = fetch2;
-  }
   /**
-   * Register a migration locally for smart sync
+   * Sync edge functions with automatic client-side bundling
    *
-   * Call this method to register migrations in your application code.
-   * When you call sync(), only new or changed migrations will be sent to the server.
+   * This is a convenience method that bundles all function code using esbuild
+   * before sending to the server. Requires esbuild as a peer dependency.
    *
-   * @param migration - Migration definition
-   * @returns { error } tuple (always succeeds unless validation fails)
+   * @param options - Sync options including namespace and functions array
+   * @param bundleOptions - Optional bundling configuration
+   * @returns Promise resolving to { data, error } tuple with sync results
    *
    * @example
    * ```typescript
-   * // In your app initialization
-   * const { error: err1 } = client.admin.migrations.register({
-   *   name: '001_create_users_table',
-   *   namespace: 'myapp',
-   *   up_sql: 'CREATE TABLE app.users (...)',
-   *   down_sql: 'DROP TABLE app.users',
-   *   description: 'Initial users table'
+   * const { data, error } = await client.admin.functions.syncWithBundling({
+   *   namespace: 'default',
+   *   functions: [
+   *     { name: 'hello', code: helloCode },
+   *     { name: 'goodbye', code: goodbyeCode },
+   *   ],
+   *   options: { delete_missing: true }
    * })
-   *
+   * ```
+   */
+  async syncWithBundling(options, bundleOptions) {
+    if (!options.functions || options.functions.length === 0) {
+      return this.sync(options);
+    }
+    const hasEsbuild = await loadEsbuild();
+    if (!hasEsbuild) {
+      return {
+        data: null,
+        error: new Error(
+          "esbuild is required for client-side bundling. Install it with: npm install esbuild"
+        )
+      };
+    }
+    try {
+      const bundledFunctions = await Promise.all(
+        options.functions.map(async (fn) => {
+          if (fn.is_pre_bundled) {
+            return fn;
+          }
+          const bundled = await _FluxbaseAdminFunctions.bundleCode({
+            // Apply global bundle options first
+            ...bundleOptions,
+            // Then override with per-function values (these take priority)
+            code: fn.code,
+            // Use function's sourceDir for resolving relative imports
+            baseDir: fn.sourceDir || bundleOptions?.baseDir,
+            // Use function's nodePaths for additional module resolution
+            nodePaths: fn.nodePaths || bundleOptions?.nodePaths
+          });
+          return {
+            ...fn,
+            code: bundled.code,
+            original_code: fn.code,
+            is_pre_bundled: true
+          };
+        })
+      );
+      return this.sync({
+        ...options,
+        functions: bundledFunctions
+      });
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Bundle function code using esbuild (client-side)
+   *
+   * Transforms and bundles TypeScript/JavaScript code into a single file
+   * that can be executed by the Fluxbase edge functions runtime.
+   *
+   * Requires esbuild as a peer dependency.
+   *
+   * @param options - Bundle options including source code
+   * @returns Promise resolving to bundled code
+   * @throws Error if esbuild is not available
+   *
+   * @example
+   * ```typescript
+   * const bundled = await FluxbaseAdminFunctions.bundleCode({
+   *   code: `
+   *     import { helper } from './utils'
+   *     export default async function handler(req) {
+   *       return helper(req.body)
+   *     }
+   *   `,
+   *   minify: true,
+   * })
+   *
+   * // Use bundled code in sync
+   * await client.admin.functions.sync({
+   *   namespace: 'default',
+   *   functions: [{
+   *     name: 'my-function',
+   *     code: bundled.code,
+   *     is_pre_bundled: true,
+   *   }]
+   * })
+   * ```
+   */
+  static async bundleCode(options) {
+    return bundleCode(options);
+  }
+};
+
+// src/admin-migrations.ts
+var FluxbaseAdminMigrations = class {
+  constructor(fetch2) {
+    this.localMigrations = /* @__PURE__ */ new Map();
+    this.fetch = fetch2;
+  }
+  /**
+   * Register a migration locally for smart sync
+   *
+   * Call this method to register migrations in your application code.
+   * When you call sync(), only new or changed migrations will be sent to the server.
+   *
+   * @param migration - Migration definition
+   * @returns { error } tuple (always succeeds unless validation fails)
+   *
+   * @example
+   * ```typescript
+   * // In your app initialization
+   * const { error: err1 } = client.admin.migrations.register({
+   *   name: '001_create_users_table',
+   *   namespace: 'myapp',
+   *   up_sql: 'CREATE TABLE app.users (...)',
+   *   down_sql: 'DROP TABLE app.users',
+   *   description: 'Initial users table'
+   * })
+   *
    * const { error: err2 } = client.admin.migrations.register({
    *   name: '002_add_posts_table',
    *   namespace: 'myapp',
@@ -4816,54 +5845,16 @@ var FluxbaseAdminMigrations = class {
     }
   }
   /**
-   * Trigger schema refresh which will restart the server
-   * Handles the restart gracefully by waiting for the server to come back online
+   * Trigger schema refresh to update the REST API cache
+   * Note: Server no longer restarts - cache is invalidated instantly
    *
    * @private
    */
-  async triggerSchemaRefreshWithRestart() {
-    console.log("Triggering schema refresh (server will restart)...");
-    try {
-      const response = await this.fetch.post(
-        "/api/v1/admin/schema/refresh",
-        {}
-      );
-      console.log("Server restart initiated:", response.message || "Schema refresh in progress");
-    } catch (error) {
-      const isConnectionError = error.message?.includes("fetch failed") || error.message?.includes("ECONNREFUSED") || error.message?.includes("ECONNRESET") || error.code === "ECONNREFUSED" || error.code === "ECONNRESET";
-      if (!isConnectionError) {
-        throw error;
-      }
-      console.log("Connection dropped (expected during restart)...");
-    }
-    console.log("Waiting 6 seconds for server to restart...");
-    await this.sleep(6e3);
-    const maxAttempts = 5;
-    const baseDelay = 1e3;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      try {
-        await this.fetch.get("/health");
-        console.log("Server is back online and ready");
-        return;
-      } catch (error) {
-        const isLastAttempt = attempt === maxAttempts;
-        if (isLastAttempt) {
-          throw new Error(
-            `Server did not come back online after ${maxAttempts} attempts. Please check server logs and try again.`
-          );
-        }
-        const delay = baseDelay * Math.pow(2, attempt - 1);
-        console.log(`Server not ready yet, retrying in ${delay}ms... (attempt ${attempt}/${maxAttempts})`);
-        await this.sleep(delay);
-      }
-    }
-  }
-  /**
-   * Helper function to sleep for a given duration
-   * @private
-   */
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
+  async triggerSchemaRefresh() {
+    const response = await this.fetch.post("/api/v1/admin/schema/refresh", {});
+    console.log(
+      `Schema cache refreshed: ${response.tables} tables, ${response.views} views`
+    );
   }
   /**
    * Smart sync all registered migrations
@@ -4962,12 +5953,12 @@ var FluxbaseAdminMigrations = class {
         dry_run: options.dry_run ?? false,
         warnings: results.flatMap((r) => r.warnings || [])
       };
-      const hasChanges = combined.summary.created > 0 || combined.summary.updated > 0;
-      if (!combined.dry_run && hasChanges) {
+      const migrationsAppliedSuccessfully = combined.summary.applied > 0 && combined.summary.errors === 0;
+      if (!combined.dry_run && migrationsAppliedSuccessfully) {
         try {
-          await this.triggerSchemaRefreshWithRestart();
+          await this.triggerSchemaRefresh();
         } catch (refreshError) {
-          console.warn("Schema refresh completed with warnings:", refreshError);
+          console.warn("Schema refresh warning:", refreshError);
         }
       }
       if (errors.length > 0 || combined.summary.errors > 0) {
@@ -5000,7 +5991,10 @@ var FluxbaseAdminMigrations = class {
    */
   async create(request) {
     try {
-      const data = await this.fetch.post("/api/v1/admin/migrations", request);
+      const data = await this.fetch.post(
+        "/api/v1/admin/migrations",
+        request
+      );
       return { data, error: null };
     } catch (error) {
       return { data: null, error };
@@ -5101,7 +6095,9 @@ var FluxbaseAdminMigrations = class {
   async delete(name, namespace = "default") {
     try {
       const params = new URLSearchParams({ namespace });
-      await this.fetch.delete(`/api/v1/admin/migrations/${name}?${params.toString()}`);
+      await this.fetch.delete(
+        `/api/v1/admin/migrations/${name}?${params.toString()}`
+      );
       return { data: null, error: null };
     } catch (error) {
       return { data: null, error };
@@ -5202,7 +6198,10 @@ var FluxbaseAdminMigrations = class {
    */
   async getExecutions(name, namespace = "default", limit = 50) {
     try {
-      const params = new URLSearchParams({ namespace, limit: limit.toString() });
+      const params = new URLSearchParams({
+        namespace,
+        limit: limit.toString()
+      });
       const data = await this.fetch.get(
         `/api/v1/admin/migrations/${name}/executions?${params.toString()}`
       );
@@ -5214,16 +6213,6 @@ var FluxbaseAdminMigrations = class {
 };
 
 // src/admin-jobs.ts
-var esbuild = null;
-async function loadEsbuild() {
-  if (esbuild) return true;
-  try {
-    esbuild = await import('esbuild');
-    return true;
-  } catch {
-    return false;
-  }
-}
 var FluxbaseAdminJobs = class _FluxbaseAdminJobs {
   constructor(fetch2) {
     this.fetch = fetch2;
@@ -5708,201 +6697,1418 @@ var FluxbaseAdminJobs = class _FluxbaseAdminJobs {
    * ```
    */
   static async bundleCode(options) {
-    const hasEsbuild = await loadEsbuild();
-    if (!hasEsbuild || !esbuild) {
-      throw new Error(
-        "esbuild is required for bundling. Install it with: npm install esbuild"
-      );
-    }
-    const externals = [...options.external ?? []];
-    const alias = {};
-    if (options.importMap) {
-      for (const [key, value] of Object.entries(options.importMap)) {
-        if (value.startsWith("npm:")) {
-          externals.push(key);
-        } else if (value.startsWith("https://") || value.startsWith("http://")) {
-          externals.push(key);
-        } else if (value.startsWith("/") || value.startsWith("./") || value.startsWith("../")) {
-          alias[key] = value;
-        } else {
-          externals.push(key);
-        }
-      }
-    }
-    const denoExternalPlugin = {
-      name: "deno-external",
-      setup(build) {
-        build.onResolve({ filter: /^npm:/ }, (args) => ({
-          path: args.path,
-          external: true
-        }));
-        build.onResolve({ filter: /^https?:\/\// }, (args) => ({
-          path: args.path,
-          external: true
-        }));
-        build.onResolve({ filter: /^jsr:/ }, (args) => ({
-          path: args.path,
-          external: true
-        }));
-      }
-    };
-    const resolveDir = options.baseDir || process.cwd?.() || "/";
-    const buildOptions = {
-      stdin: {
-        contents: options.code,
-        loader: "ts",
-        resolveDir
-      },
-      // Set absWorkingDir for consistent path resolution
-      absWorkingDir: resolveDir,
-      bundle: true,
-      write: false,
-      format: "esm",
-      // Use 'node' platform for better node_modules resolution (Deno supports Node APIs)
-      platform: "node",
-      target: "esnext",
-      minify: options.minify ?? false,
-      sourcemap: options.sourcemap ? "inline" : false,
-      external: externals,
-      plugins: [denoExternalPlugin],
-      // Preserve handler export
-      treeShaking: true,
-      // Resolve .ts, .js, .mjs extensions
-      resolveExtensions: [".ts", ".tsx", ".js", ".mjs", ".json"],
-      // ESM conditions for better module resolution
-      conditions: ["import", "module"]
-    };
-    if (Object.keys(alias).length > 0) {
-      buildOptions.alias = alias;
-    }
-    if (options.nodePaths && options.nodePaths.length > 0) {
-      buildOptions.nodePaths = options.nodePaths;
-    }
-    if (options.define) {
-      buildOptions.define = options.define;
-    }
-    const result = await esbuild.build(buildOptions);
-    const output = result.outputFiles?.[0];
-    if (!output) {
-      throw new Error("Bundling failed: no output generated");
-    }
-    return {
-      code: output.text,
-      sourceMap: options.sourcemap ? output.text : void 0
-    };
+    return bundleCode(options);
   }
 };
 
-// src/admin.ts
-var FluxbaseAdmin = class {
+// src/admin-ai.ts
+var FluxbaseAdminAI = class {
   constructor(fetch2) {
-    this.adminToken = null;
     this.fetch = fetch2;
-    this.settings = new FluxbaseSettings(fetch2);
-    this.ddl = new DDLManager(fetch2);
-    this.oauth = new FluxbaseOAuth(fetch2);
-    this.impersonation = new ImpersonationManager(fetch2);
-    this.management = new FluxbaseManagement(fetch2);
-    this.emailTemplates = new EmailTemplateManager(fetch2);
-    this.functions = new FluxbaseAdminFunctions(fetch2);
-    this.jobs = new FluxbaseAdminJobs(fetch2);
-    this.migrations = new FluxbaseAdminMigrations(fetch2);
-  }
-  /**
-   * Set admin authentication token
-   */
-  setToken(token) {
-    this.adminToken = token;
-    this.fetch.setAuthToken(token);
-  }
-  /**
-   * Get current admin token
-   */
-  getToken() {
-    return this.adminToken;
-  }
-  /**
-   * Clear admin token
-   */
-  clearToken() {
-    this.adminToken = null;
-    this.fetch.setAuthToken(null);
   }
   // ============================================================================
-  // Admin Authentication
+  // CHATBOT MANAGEMENT
   // ============================================================================
   /**
-   * Check if initial admin setup is needed
+   * List all chatbots (admin view)
    *
-   * @returns Setup status indicating if initial setup is required
+   * @param namespace - Optional namespace filter
+   * @returns Promise resolving to { data, error } tuple with array of chatbot summaries
    *
    * @example
    * ```typescript
-   * const status = await admin.getSetupStatus();
-   * if (status.needs_setup) {
-   *   console.log('Initial setup required');
+   * const { data, error } = await client.admin.ai.listChatbots()
+   * if (data) {
+   *   console.log('Chatbots:', data.map(c => c.name))
    * }
    * ```
    */
-  async getSetupStatus() {
-    return wrapAsync(async () => {
-      return await this.fetch.get(
-        "/api/v1/admin/setup/status"
-      );
-    });
+  async listChatbots(namespace) {
+    try {
+      const params = namespace ? `?namespace=${namespace}` : "";
+      const response = await this.fetch.get(`/api/v1/admin/ai/chatbots${params}`);
+      return { data: response.chatbots || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
   }
   /**
-   * Perform initial admin setup
-   *
-   * Creates the first admin user and completes initial setup.
-   * This endpoint can only be called once.
+   * Get details of a specific chatbot
    *
-   * @param request - Setup request containing email, password, and name
-   * @returns Authentication response with tokens
+   * @param id - Chatbot ID
+   * @returns Promise resolving to { data, error } tuple with chatbot details
    *
    * @example
    * ```typescript
-   * const response = await admin.setup({
-   *   email: 'admin@example.com',
-   *   password: 'SecurePassword123!',
-   *   name: 'Admin User'
-   * });
-   *
-   * // Store tokens
-   * localStorage.setItem('admin_token', response.access_token);
+   * const { data, error } = await client.admin.ai.getChatbot('uuid')
+   * if (data) {
+   *   console.log('Chatbot:', data.name)
+   * }
    * ```
    */
-  async setup(request) {
-    return wrapAsync(async () => {
-      const response = await this.fetch.post(
-        "/api/v1/admin/setup",
-        request
+  async getChatbot(id) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/chatbots/${id}`
       );
-      this.setToken(response.access_token);
-      return response;
-    });
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
   }
   /**
-   * Admin login
-   *
-   * Authenticate as an admin user
+   * Enable or disable a chatbot
    *
-   * @param request - Login request containing email and password
-   * @returns Authentication response with tokens
+   * @param id - Chatbot ID
+   * @param enabled - Whether to enable or disable
+   * @returns Promise resolving to { data, error } tuple with updated chatbot
    *
    * @example
    * ```typescript
-   * const response = await admin.login({
-   *   email: 'admin@example.com',
-   *   password: 'password123'
-   * });
-   *
-   * // Token is automatically set in the client
-   * console.log('Logged in as:', response.user.email);
+   * const { data, error } = await client.admin.ai.toggleChatbot('uuid', true)
    * ```
    */
-  async login(request) {
-    return wrapAsync(async () => {
+  async toggleChatbot(id, enabled) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/ai/chatbots/${id}/toggle`,
+        { enabled }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a chatbot
+   *
+   * @param id - Chatbot ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.deleteChatbot('uuid')
+   * ```
+   */
+  async deleteChatbot(id) {
+    try {
+      await this.fetch.delete(`/api/v1/admin/ai/chatbots/${id}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Sync chatbots from filesystem or API payload
+   *
+   * Can sync from:
+   * 1. Filesystem (if no chatbots provided) - loads from configured chatbots directory
+   * 2. API payload (if chatbots array provided) - syncs provided chatbot specifications
+   *
+   * Requires service_role or admin authentication.
+   *
+   * @param options - Sync options including namespace and optional chatbots array
+   * @returns Promise resolving to { data, error } tuple with sync results
+   *
+   * @example
+   * ```typescript
+   * // Sync from filesystem
+   * const { data, error } = await client.admin.ai.sync()
+   *
+   * // Sync with provided chatbot code
+   * const { data, error } = await client.admin.ai.sync({
+   *   namespace: 'default',
+   *   chatbots: [{
+   *     name: 'sql-assistant',
+   *     code: myChatbotCode,
+   *   }],
+   *   options: {
+   *     delete_missing: false, // Don't remove chatbots not in this sync
+   *     dry_run: false,        // Preview changes without applying
+   *   }
+   * })
+   *
+   * if (data) {
+   *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+   * }
+   * ```
+   */
+  async sync(options) {
+    try {
+      const data = await this.fetch.post(
+        "/api/v1/admin/ai/chatbots/sync",
+        {
+          namespace: options?.namespace || "default",
+          chatbots: options?.chatbots,
+          options: {
+            delete_missing: options?.options?.delete_missing ?? false,
+            dry_run: options?.options?.dry_run ?? false
+          }
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // PROVIDER MANAGEMENT
+  // ============================================================================
+  /**
+   * List all AI providers
+   *
+   * @returns Promise resolving to { data, error } tuple with array of providers
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.listProviders()
+   * if (data) {
+   *   console.log('Providers:', data.map(p => p.name))
+   * }
+   * ```
+   */
+  async listProviders() {
+    try {
+      const response = await this.fetch.get("/api/v1/admin/ai/providers");
+      return { data: response.providers || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific provider
+   *
+   * @param id - Provider ID
+   * @returns Promise resolving to { data, error } tuple with provider details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getProvider('uuid')
+   * if (data) {
+   *   console.log('Provider:', data.display_name)
+   * }
+   * ```
+   */
+  async getProvider(id) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/providers/${id}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new AI provider
+   *
+   * @param request - Provider configuration
+   * @returns Promise resolving to { data, error } tuple with created provider
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.createProvider({
+   *   name: 'openai-main',
+   *   display_name: 'OpenAI (Main)',
+   *   provider_type: 'openai',
+   *   is_default: true,
+   *   config: {
+   *     api_key: 'sk-...',
+   *     model: 'gpt-4-turbo',
+   *   }
+   * })
+   * ```
+   */
+  async createProvider(request) {
+    try {
+      const data = await this.fetch.post(
+        "/api/v1/admin/ai/providers",
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update an existing AI provider
+   *
+   * @param id - Provider ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated provider
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.updateProvider('uuid', {
+   *   display_name: 'Updated Name',
+   *   config: {
+   *     api_key: 'new-key',
+   *     model: 'gpt-4-turbo',
+   *   },
+   *   enabled: true,
+   * })
+   * ```
+   */
+  async updateProvider(id, updates) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/ai/providers/${id}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Set a provider as the default
+   *
+   * @param id - Provider ID
+   * @returns Promise resolving to { data, error } tuple with updated provider
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.setDefaultProvider('uuid')
+   * ```
+   */
+  async setDefaultProvider(id) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/ai/providers/${id}/default`,
+        {}
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a provider
+   *
+   * @param id - Provider ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.deleteProvider('uuid')
+   * ```
+   */
+  async deleteProvider(id) {
+    try {
+      await this.fetch.delete(`/api/v1/admin/ai/providers/${id}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // KNOWLEDGE BASE MANAGEMENT (RAG)
+  // ============================================================================
+  /**
+   * List all knowledge bases
+   *
+   * @returns Promise resolving to { data, error } tuple with array of knowledge base summaries
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.listKnowledgeBases()
+   * if (data) {
+   *   console.log('Knowledge bases:', data.map(kb => kb.name))
+   * }
+   * ```
+   */
+  async listKnowledgeBases() {
+    try {
+      const response = await this.fetch.get("/api/v1/admin/ai/knowledge-bases");
+      return { data: response.knowledge_bases || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get a specific knowledge base
+   *
+   * @param id - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple with knowledge base details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getKnowledgeBase('uuid')
+   * if (data) {
+   *   console.log('Knowledge base:', data.name)
+   * }
+   * ```
+   */
+  async getKnowledgeBase(id) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/knowledge-bases/${id}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new knowledge base
+   *
+   * @param request - Knowledge base configuration
+   * @returns Promise resolving to { data, error } tuple with created knowledge base
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.createKnowledgeBase({
+   *   name: 'product-docs',
+   *   description: 'Product documentation',
+   *   chunk_size: 512,
+   *   chunk_overlap: 50,
+   * })
+   * ```
+   */
+  async createKnowledgeBase(request) {
+    try {
+      const data = await this.fetch.post(
+        "/api/v1/admin/ai/knowledge-bases",
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update an existing knowledge base
+   *
+   * @param id - Knowledge base ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated knowledge base
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.updateKnowledgeBase('uuid', {
+   *   description: 'Updated description',
+   *   enabled: true,
+   * })
+   * ```
+   */
+  async updateKnowledgeBase(id, updates) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/ai/knowledge-bases/${id}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a knowledge base
+   *
+   * @param id - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.deleteKnowledgeBase('uuid')
+   * ```
+   */
+  async deleteKnowledgeBase(id) {
+    try {
+      await this.fetch.delete(`/api/v1/admin/ai/knowledge-bases/${id}`);
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // DOCUMENT MANAGEMENT
+  // ============================================================================
+  /**
+   * List documents in a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple with array of documents
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.listDocuments('kb-uuid')
+   * if (data) {
+   *   console.log('Documents:', data.map(d => d.title))
+   * }
+   * ```
+   */
+  async listDocuments(knowledgeBaseId) {
+    try {
+      const response = await this.fetch.get(`/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents`);
+      return { data: response.documents || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get a specific document
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param documentId - Document ID
+   * @returns Promise resolving to { data, error } tuple with document details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getDocument('kb-uuid', 'doc-uuid')
+   * ```
+   */
+  async getDocument(knowledgeBaseId, documentId) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents/${documentId}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Add a document to a knowledge base
+   *
+   * Document will be chunked and embedded asynchronously.
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param request - Document content and metadata
+   * @returns Promise resolving to { data, error } tuple with document ID
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.addDocument('kb-uuid', {
+   *   title: 'Getting Started Guide',
+   *   content: 'This is the content of the document...',
+   *   metadata: { category: 'guides' },
+   * })
+   * if (data) {
+   *   console.log('Document ID:', data.document_id)
+   * }
+   * ```
+   */
+  async addDocument(knowledgeBaseId, request) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Upload a document file to a knowledge base
+   *
+   * Supported file types: PDF, TXT, MD, HTML, CSV, DOCX, XLSX, RTF, EPUB, JSON
+   * Maximum file size: 50MB
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param file - File to upload (File or Blob)
+   * @param title - Optional document title (defaults to filename without extension)
+   * @returns Promise resolving to { data, error } tuple with upload result
+   *
+   * @example
+   * ```typescript
+   * // Browser
+   * const fileInput = document.getElementById('file') as HTMLInputElement
+   * const file = fileInput.files?.[0]
+   * if (file) {
+   *   const { data, error } = await client.admin.ai.uploadDocument('kb-uuid', file)
+   *   if (data) {
+   *     console.log('Document ID:', data.document_id)
+   *     console.log('Extracted length:', data.extracted_length)
+   *   }
+   * }
+   *
+   * // Node.js (with node-fetch or similar)
+   * import { Blob } from 'buffer'
+   * const content = await fs.readFile('document.pdf')
+   * const blob = new Blob([content], { type: 'application/pdf' })
+   * const { data, error } = await client.admin.ai.uploadDocument('kb-uuid', blob, 'My Document')
+   * ```
+   */
+  async uploadDocument(knowledgeBaseId, file, title) {
+    try {
+      const formData = new FormData();
+      formData.append("file", file);
+      if (title) {
+        formData.append("title", title);
+      }
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents/upload`,
+        formData
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a document from a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param documentId - Document ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.deleteDocument('kb-uuid', 'doc-uuid')
+   * ```
+   */
+  async deleteDocument(knowledgeBaseId, documentId) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/documents/${documentId}`
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Search a knowledge base
+   *
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param query - Search query
+   * @param options - Search options
+   * @returns Promise resolving to { data, error } tuple with search results
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.searchKnowledgeBase('kb-uuid', 'how to reset password', {
+   *   max_chunks: 5,
+   *   threshold: 0.7,
+   * })
+   * if (data) {
+   *   console.log('Results:', data.results.map(r => r.content))
+   * }
+   * ```
+   */
+  async searchKnowledgeBase(knowledgeBaseId, query, options) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/knowledge-bases/${knowledgeBaseId}/search`,
+        {
+          query,
+          max_chunks: options?.max_chunks,
+          threshold: options?.threshold
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // CHATBOT KNOWLEDGE BASE LINKING
+  // ============================================================================
+  /**
+   * List knowledge bases linked to a chatbot
+   *
+   * @param chatbotId - Chatbot ID
+   * @returns Promise resolving to { data, error } tuple with linked knowledge bases
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.listChatbotKnowledgeBases('chatbot-uuid')
+   * if (data) {
+   *   console.log('Linked KBs:', data.map(l => l.knowledge_base_id))
+   * }
+   * ```
+   */
+  async listChatbotKnowledgeBases(chatbotId) {
+    try {
+      const response = await this.fetch.get(`/api/v1/admin/ai/chatbots/${chatbotId}/knowledge-bases`);
+      return { data: response.knowledge_bases || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Link a knowledge base to a chatbot
+   *
+   * @param chatbotId - Chatbot ID
+   * @param request - Link configuration
+   * @returns Promise resolving to { data, error } tuple with link details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.linkKnowledgeBase('chatbot-uuid', {
+   *   knowledge_base_id: 'kb-uuid',
+   *   priority: 1,
+   *   max_chunks: 5,
+   *   similarity_threshold: 0.7,
+   * })
+   * ```
+   */
+  async linkKnowledgeBase(chatbotId, request) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/ai/chatbots/${chatbotId}/knowledge-bases`,
+        request
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update a chatbot-knowledge base link
+   *
+   * @param chatbotId - Chatbot ID
+   * @param knowledgeBaseId - Knowledge base ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated link
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.updateChatbotKnowledgeBase(
+   *   'chatbot-uuid',
+   *   'kb-uuid',
+   *   { max_chunks: 10, enabled: true }
+   * )
+   * ```
+   */
+  async updateChatbotKnowledgeBase(chatbotId, knowledgeBaseId, updates) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/ai/chatbots/${chatbotId}/knowledge-bases/${knowledgeBaseId}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Unlink a knowledge base from a chatbot
+   *
+   * @param chatbotId - Chatbot ID
+   * @param knowledgeBaseId - Knowledge base ID
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.unlinkKnowledgeBase('chatbot-uuid', 'kb-uuid')
+   * ```
+   */
+  async unlinkKnowledgeBase(chatbotId, knowledgeBaseId) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/admin/ai/chatbots/${chatbotId}/knowledge-bases/${knowledgeBaseId}`
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/admin-rpc.ts
+var FluxbaseAdminRPC = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  // ============================================================================
+  // PROCEDURE MANAGEMENT
+  // ============================================================================
+  /**
+   * Sync RPC procedures from filesystem or API payload
+   *
+   * Can sync from:
+   * 1. Filesystem (if no procedures provided) - loads from configured procedures directory
+   * 2. API payload (if procedures array provided) - syncs provided procedure specifications
+   *
+   * Requires service_role or admin authentication.
+   *
+   * @param options - Sync options including namespace and optional procedures array
+   * @returns Promise resolving to { data, error } tuple with sync results
+   *
+   * @example
+   * ```typescript
+   * // Sync from filesystem
+   * const { data, error } = await client.admin.rpc.sync()
+   *
+   * // Sync with provided procedure code
+   * const { data, error } = await client.admin.rpc.sync({
+   *   namespace: 'default',
+   *   procedures: [{
+   *     name: 'get-user-orders',
+   *     code: myProcedureSQL,
+   *   }],
+   *   options: {
+   *     delete_missing: false, // Don't remove procedures not in this sync
+   *     dry_run: false,        // Preview changes without applying
+   *   }
+   * })
+   *
+   * if (data) {
+   *   console.log(`Synced: ${data.summary.created} created, ${data.summary.updated} updated`)
+   * }
+   * ```
+   */
+  async sync(options) {
+    try {
+      const data = await this.fetch.post(
+        "/api/v1/admin/rpc/sync",
+        {
+          namespace: options?.namespace || "default",
+          procedures: options?.procedures,
+          options: {
+            delete_missing: options?.options?.delete_missing ?? false,
+            dry_run: options?.options?.dry_run ?? false
+          }
+        }
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all RPC procedures (admin view)
+   *
+   * @param namespace - Optional namespace filter
+   * @returns Promise resolving to { data, error } tuple with array of procedure summaries
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.list()
+   * if (data) {
+   *   console.log('Procedures:', data.map(p => p.name))
+   * }
+   * ```
+   */
+  async list(namespace) {
+    try {
+      const params = namespace ? `?namespace=${encodeURIComponent(namespace)}` : "";
+      const response = await this.fetch.get(
+        `/api/v1/admin/rpc/procedures${params}`
+      );
+      return { data: response.procedures || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * List all namespaces
+   *
+   * @returns Promise resolving to { data, error } tuple with array of namespace names
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.listNamespaces()
+   * if (data) {
+   *   console.log('Namespaces:', data)
+   * }
+   * ```
+   */
+  async listNamespaces() {
+    try {
+      const response = await this.fetch.get(
+        "/api/v1/admin/rpc/namespaces"
+      );
+      return { data: response.namespaces || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific RPC procedure
+   *
+   * @param namespace - Procedure namespace
+   * @param name - Procedure name
+   * @returns Promise resolving to { data, error } tuple with procedure details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.get('default', 'get-user-orders')
+   * if (data) {
+   *   console.log('Procedure:', data.name)
+   *   console.log('SQL:', data.sql_query)
+   * }
+   * ```
+   */
+  async get(namespace, name) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/rpc/procedures/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Update an RPC procedure
+   *
+   * @param namespace - Procedure namespace
+   * @param name - Procedure name
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated procedure
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.update('default', 'get-user-orders', {
+   *   enabled: false,
+   *   max_execution_time_seconds: 60,
+   * })
+   * ```
+   */
+  async update(namespace, name, updates) {
+    try {
+      const data = await this.fetch.put(
+        `/api/v1/admin/rpc/procedures/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`,
+        updates
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Enable or disable an RPC procedure
+   *
+   * @param namespace - Procedure namespace
+   * @param name - Procedure name
+   * @param enabled - Whether to enable or disable
+   * @returns Promise resolving to { data, error } tuple with updated procedure
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.toggle('default', 'get-user-orders', true)
+   * ```
+   */
+  async toggle(namespace, name, enabled) {
+    return this.update(namespace, name, { enabled });
+  }
+  /**
+   * Delete an RPC procedure
+   *
+   * @param namespace - Procedure namespace
+   * @param name - Procedure name
+   * @returns Promise resolving to { data, error } tuple
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.delete('default', 'get-user-orders')
+   * ```
+   */
+  async delete(namespace, name) {
+    try {
+      await this.fetch.delete(
+        `/api/v1/admin/rpc/procedures/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`
+      );
+      return { data: null, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  // ============================================================================
+  // EXECUTION MONITORING
+  // ============================================================================
+  /**
+   * List RPC executions with optional filters
+   *
+   * @param filters - Optional filters for namespace, procedure, status, user
+   * @returns Promise resolving to { data, error } tuple with array of executions
+   *
+   * @example
+   * ```typescript
+   * // List all executions
+   * const { data, error } = await client.admin.rpc.listExecutions()
+   *
+   * // List failed executions for a specific procedure
+   * const { data, error } = await client.admin.rpc.listExecutions({
+   *   namespace: 'default',
+   *   procedure: 'get-user-orders',
+   *   status: 'failed',
+   * })
+   * ```
+   */
+  async listExecutions(filters) {
+    try {
+      const params = new URLSearchParams();
+      if (filters?.namespace) params.set("namespace", filters.namespace);
+      if (filters?.procedure) params.set("procedure_name", filters.procedure);
+      if (filters?.status) params.set("status", filters.status);
+      if (filters?.user_id) params.set("user_id", filters.user_id);
+      if (filters?.limit) params.set("limit", filters.limit.toString());
+      if (filters?.offset) params.set("offset", filters.offset.toString());
+      const queryString = params.toString();
+      const path = queryString ? `/api/v1/admin/rpc/executions?${queryString}` : "/api/v1/admin/rpc/executions";
+      const response = await this.fetch.get(path);
+      return { data: response.executions || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific execution
+   *
+   * @param executionId - Execution ID
+   * @returns Promise resolving to { data, error } tuple with execution details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.getExecution('execution-uuid')
+   * if (data) {
+   *   console.log('Status:', data.status)
+   *   console.log('Duration:', data.duration_ms, 'ms')
+   * }
+   * ```
+   */
+  async getExecution(executionId) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/rpc/executions/${encodeURIComponent(executionId)}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get execution logs for a specific execution
+   *
+   * @param executionId - Execution ID
+   * @param afterLine - Optional line number to get logs after (for polling)
+   * @returns Promise resolving to { data, error } tuple with execution logs
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.getExecutionLogs('execution-uuid')
+   * if (data) {
+   *   for (const log of data) {
+   *     console.log(`[${log.level}] ${log.message}`)
+   *   }
+   * }
+   * ```
+   */
+  async getExecutionLogs(executionId, afterLine) {
+    try {
+      const params = afterLine !== void 0 ? `?after=${afterLine}` : "";
+      const response = await this.fetch.get(
+        `/api/v1/admin/rpc/executions/${encodeURIComponent(executionId)}/logs${params}`
+      );
+      return { data: response.logs || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Cancel a running execution
+   *
+   * @param executionId - Execution ID
+   * @returns Promise resolving to { data, error } tuple with updated execution
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.rpc.cancelExecution('execution-uuid')
+   * ```
+   */
+  async cancelExecution(executionId) {
+    try {
+      const data = await this.fetch.post(
+        `/api/v1/admin/rpc/executions/${encodeURIComponent(executionId)}/cancel`,
+        {}
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/admin-storage.ts
+var FluxbaseAdminStorage = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  // ============================================================================
+  // Bucket Operations
+  // ============================================================================
+  /**
+   * List all storage buckets
+   *
+   * @returns List of buckets
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await admin.storage.listBuckets();
+   * if (data) {
+   *   console.log(`Found ${data.buckets.length} buckets`);
+   * }
+   * ```
+   */
+  async listBuckets() {
+    return wrapAsync(async () => {
+      return await this.fetch.get(
+        "/api/v1/storage/buckets"
+      );
+    });
+  }
+  /**
+   * Create a new storage bucket
+   *
+   * @param name - Bucket name
+   * @returns Success message
+   *
+   * @example
+   * ```typescript
+   * const { error } = await admin.storage.createBucket('my-bucket');
+   * if (!error) {
+   *   console.log('Bucket created');
+   * }
+   * ```
+   */
+  async createBucket(name) {
+    return wrapAsync(async () => {
+      return await this.fetch.post(
+        `/api/v1/storage/buckets/${encodeURIComponent(name)}`
+      );
+    });
+  }
+  /**
+   * Delete a storage bucket
+   *
+   * @param name - Bucket name
+   * @returns Success message
+   *
+   * @example
+   * ```typescript
+   * const { error } = await admin.storage.deleteBucket('my-bucket');
+   * if (!error) {
+   *   console.log('Bucket deleted');
+   * }
+   * ```
+   */
+  async deleteBucket(name) {
+    return wrapAsync(async () => {
+      return await this.fetch.delete(
+        `/api/v1/storage/buckets/${encodeURIComponent(name)}`
+      );
+    });
+  }
+  // ============================================================================
+  // Object Operations
+  // ============================================================================
+  /**
+   * List objects in a bucket
+   *
+   * @param bucket - Bucket name
+   * @param prefix - Optional path prefix to filter results
+   * @param delimiter - Optional delimiter for hierarchical listing (usually '/')
+   * @returns List of objects and prefixes (folders)
+   *
+   * @example
+   * ```typescript
+   * // List all objects in bucket
+   * const { data } = await admin.storage.listObjects('my-bucket');
+   *
+   * // List objects in a folder
+   * const { data } = await admin.storage.listObjects('my-bucket', 'folder/', '/');
+   * ```
+   */
+  async listObjects(bucket, prefix, delimiter) {
+    return wrapAsync(async () => {
+      const params = new URLSearchParams();
+      if (prefix) params.append("prefix", prefix);
+      if (delimiter) params.append("delimiter", delimiter);
+      const queryString = params.toString();
+      const url = `/api/v1/storage/${encodeURIComponent(bucket)}${queryString ? `?${queryString}` : ""}`;
+      return await this.fetch.get(url);
+    });
+  }
+  /**
+   * Get object metadata
+   *
+   * @param bucket - Bucket name
+   * @param key - Object key (path)
+   * @returns Object metadata
+   *
+   * @example
+   * ```typescript
+   * const { data } = await admin.storage.getObjectMetadata('my-bucket', 'path/to/file.txt');
+   * if (data) {
+   *   console.log(`File size: ${data.size} bytes`);
+   * }
+   * ```
+   */
+  async getObjectMetadata(bucket, key) {
+    return wrapAsync(async () => {
+      const encodedKey = key.split("/").map((s) => encodeURIComponent(s)).join("/");
+      return await this.fetch.get(
+        `/api/v1/storage/${encodeURIComponent(bucket)}/${encodedKey}`,
+        {
+          headers: { "X-Metadata-Only": "true" }
+        }
+      );
+    });
+  }
+  /**
+   * Download an object as a Blob
+   *
+   * @param bucket - Bucket name
+   * @param key - Object key (path)
+   * @returns Object data as Blob
+   *
+   * @example
+   * ```typescript
+   * const { data: blob } = await admin.storage.downloadObject('my-bucket', 'file.pdf');
+   * if (blob) {
+   *   // Use the blob
+   *   const url = URL.createObjectURL(blob);
+   * }
+   * ```
+   */
+  async downloadObject(bucket, key) {
+    return wrapAsync(async () => {
+      const encodedKey = key.split("/").map((s) => encodeURIComponent(s)).join("/");
+      const response = await this.fetch.getBlob(
+        `/api/v1/storage/${encodeURIComponent(bucket)}/${encodedKey}`
+      );
+      return response;
+    });
+  }
+  /**
+   * Delete an object
+   *
+   * @param bucket - Bucket name
+   * @param key - Object key (path)
+   *
+   * @example
+   * ```typescript
+   * const { error } = await admin.storage.deleteObject('my-bucket', 'path/to/file.txt');
+   * if (!error) {
+   *   console.log('Object deleted');
+   * }
+   * ```
+   */
+  async deleteObject(bucket, key) {
+    return wrapAsyncVoid(async () => {
+      const encodedKey = key.split("/").map((s) => encodeURIComponent(s)).join("/");
+      await this.fetch.delete(
+        `/api/v1/storage/${encodeURIComponent(bucket)}/${encodedKey}`
+      );
+    });
+  }
+  /**
+   * Create a folder (empty object with directory content type)
+   *
+   * @param bucket - Bucket name
+   * @param folderPath - Folder path (should end with /)
+   *
+   * @example
+   * ```typescript
+   * const { error } = await admin.storage.createFolder('my-bucket', 'new-folder/');
+   * ```
+   */
+  async createFolder(bucket, folderPath) {
+    return wrapAsyncVoid(async () => {
+      const encodedPath = folderPath.split("/").map((s) => encodeURIComponent(s)).join("/");
+      await this.fetch.post(
+        `/api/v1/storage/${encodeURIComponent(bucket)}/${encodedPath}`,
+        null,
+        {
+          headers: { "Content-Type": "application/x-directory" }
+        }
+      );
+    });
+  }
+  /**
+   * Generate a signed URL for temporary access
+   *
+   * @param bucket - Bucket name
+   * @param key - Object key (path)
+   * @param expiresIn - Expiration time in seconds
+   * @returns Signed URL and expiration info
+   *
+   * @example
+   * ```typescript
+   * const { data } = await admin.storage.generateSignedUrl('my-bucket', 'file.pdf', 3600);
+   * if (data) {
+   *   console.log(`Download at: ${data.url}`);
+   *   console.log(`Expires in: ${data.expires_in} seconds`);
+   * }
+   * ```
+   */
+  async generateSignedUrl(bucket, key, expiresIn) {
+    return wrapAsync(async () => {
+      const encodedKey = key.split("/").map((s) => encodeURIComponent(s)).join("/");
+      return await this.fetch.post(
+        `/api/v1/storage/${encodeURIComponent(bucket)}/${encodedKey}/signed-url`,
+        { expires_in: expiresIn }
+      );
+    });
+  }
+};
+
+// src/admin.ts
+var FluxbaseAdmin = class {
+  constructor(fetch2) {
+    this.adminToken = null;
+    this.fetch = fetch2;
+    this.settings = new FluxbaseSettings(fetch2);
+    this.ddl = new DDLManager(fetch2);
+    this.oauth = new FluxbaseOAuth(fetch2);
+    this.impersonation = new ImpersonationManager(fetch2);
+    this.management = new FluxbaseManagement(fetch2);
+    this.emailTemplates = new EmailTemplateManager(fetch2);
+    this.functions = new FluxbaseAdminFunctions(fetch2);
+    this.jobs = new FluxbaseAdminJobs(fetch2);
+    this.migrations = new FluxbaseAdminMigrations(fetch2);
+    this.ai = new FluxbaseAdminAI(fetch2);
+    this.rpc = new FluxbaseAdminRPC(fetch2);
+    this.storage = new FluxbaseAdminStorage(fetch2);
+  }
+  /**
+   * Set admin authentication token
+   */
+  setToken(token) {
+    this.adminToken = token;
+    this.fetch.setAuthToken(token);
+  }
+  /**
+   * Get current admin token
+   */
+  getToken() {
+    return this.adminToken;
+  }
+  /**
+   * Clear admin token
+   */
+  clearToken() {
+    this.adminToken = null;
+    this.fetch.setAuthToken(null);
+  }
+  // ============================================================================
+  // Health Check
+  // ============================================================================
+  /**
+   * Get system health status
+   *
+   * @returns Health status including database and realtime service status
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await admin.getHealth();
+   * if (data) {
+   *   console.log('Status:', data.status);
+   *   console.log('Database:', data.services.database);
+   *   console.log('Realtime:', data.services.realtime);
+   * }
+   * ```
+   */
+  async getHealth() {
+    return wrapAsync(async () => {
+      return await this.fetch.get("/health");
+    });
+  }
+  // ============================================================================
+  // Email
+  // ============================================================================
+  /**
+   * Send an email
+   *
+   * @param request - Email details (to, subject, html/text)
+   *
+   * @example
+   * ```typescript
+   * const { error } = await admin.sendEmail({
+   *   to: 'user@example.com',
+   *   subject: 'Hello',
+   *   html: '<p>Your message here</p>'
+   * });
+   * if (!error) {
+   *   console.log('Email sent');
+   * }
+   * ```
+   */
+  async sendEmail(request) {
+    return wrapAsyncVoid(async () => {
+      await this.fetch.post("/api/v1/admin/email/send", request);
+    });
+  }
+  // ============================================================================
+  // Admin Authentication
+  // ============================================================================
+  /**
+   * Check if initial admin setup is needed
+   *
+   * @returns Setup status indicating if initial setup is required
+   *
+   * @example
+   * ```typescript
+   * const status = await admin.getSetupStatus();
+   * if (status.needs_setup) {
+   *   console.log('Initial setup required');
+   * }
+   * ```
+   */
+  async getSetupStatus() {
+    return wrapAsync(async () => {
+      return await this.fetch.get(
+        "/api/v1/admin/setup/status"
+      );
+    });
+  }
+  /**
+   * Perform initial admin setup
+   *
+   * Creates the first admin user and completes initial setup.
+   * This endpoint can only be called once.
+   *
+   * @param request - Setup request containing email, password, and name
+   * @returns Authentication response with tokens
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.setup({
+   *   email: 'admin@example.com',
+   *   password: 'SecurePassword123!',
+   *   name: 'Admin User'
+   * });
+   *
+   * // Store tokens
+   * localStorage.setItem('admin_token', response.access_token);
+   * ```
+   */
+  async setup(request) {
+    return wrapAsync(async () => {
+      const response = await this.fetch.post(
+        "/api/v1/admin/setup",
+        request
+      );
+      this.setToken(response.access_token);
+      return response;
+    });
+  }
+  /**
+   * Admin login
+   *
+   * Authenticate as an admin user
+   *
+   * @param request - Login request containing email and password
+   * @returns Authentication response with tokens
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.login({
+   *   email: 'admin@example.com',
+   *   password: 'password123'
+   * });
+   *
+   * // Token is automatically set in the client
+   * console.log('Logged in as:', response.user.email);
+   * ```
+   */
+  async login(request) {
+    return wrapAsync(async () => {
       const response = await this.fetch.post(
         "/api/v1/admin/login",
         request
@@ -6072,79 +8278,558 @@ var FluxbaseAdmin = class {
    *
    * Permanently deletes a user and all associated data
    *
-   * @param userId - User ID to delete
-   * @param type - User type ('app' or 'dashboard')
-   * @returns Deletion confirmation
+   * @param userId - User ID to delete
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Deletion confirmation
+   *
+   * @example
+   * ```typescript
+   * await admin.deleteUser('user-uuid');
+   * console.log('User deleted');
+   * ```
+   */
+  async deleteUser(userId, type = "app") {
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}?type=${type}`;
+      return await this.fetch.delete(url);
+    });
+  }
+  /**
+   * Update user role
+   *
+   * Changes a user's role
+   *
+   * @param userId - User ID
+   * @param role - New role
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Updated user
+   *
+   * @example
+   * ```typescript
+   * const user = await admin.updateUserRole('user-uuid', 'admin');
+   * console.log('User role updated:', user.role);
+   * ```
+   */
+  async updateUserRole(userId, role, type = "app") {
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}/role?type=${type}`;
+      return await this.fetch.patch(url, { role });
+    });
+  }
+  /**
+   * Reset user password
+   *
+   * Generates a new password for the user and optionally sends it via email
+   *
+   * @param userId - User ID
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Reset confirmation message
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.resetUserPassword('user-uuid');
+   * console.log(response.message);
+   * ```
+   */
+  async resetUserPassword(userId, type = "app") {
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}/reset-password?type=${type}`;
+      return await this.fetch.post(url, {});
+    });
+  }
+};
+
+// src/ai.ts
+var FluxbaseAIChat = class {
+  constructor(options) {
+    this.ws = null;
+    this.reconnectCount = 0;
+    this.pendingStartResolve = null;
+    this.pendingStartReject = null;
+    this.accumulatedContent = /* @__PURE__ */ new Map();
+    this.options = {
+      reconnectAttempts: 3,
+      reconnectDelay: 1e3,
+      ...options
+    };
+  }
+  /**
+   * Connect to the AI chat WebSocket
+   *
+   * @returns Promise that resolves when connected
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const url = this.buildWsUrl();
+      try {
+        this.ws = new WebSocket(url);
+        this.ws.onopen = () => {
+          this.reconnectCount = 0;
+          this.emitEvent({ type: "connected" });
+          resolve();
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+        this.ws.onclose = (event) => {
+          this.emitEvent({ type: "disconnected" });
+          this.handleClose(event);
+        };
+        this.ws.onerror = () => {
+          reject(new Error("WebSocket connection failed"));
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the AI chat WebSocket
+   */
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Start a new chat session with a chatbot
+   *
+   * @param chatbot - Chatbot name
+   * @param namespace - Optional namespace (defaults to 'default')
+   * @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;
+      }
+      this.pendingStartResolve = resolve;
+      this.pendingStartReject = reject;
+      const message = {
+        type: "start_chat",
+        chatbot,
+        namespace: namespace || "default",
+        conversation_id: conversationId,
+        impersonate_user_id: impersonateUserId
+      };
+      this.ws.send(JSON.stringify(message));
+    });
+  }
+  /**
+   * Send a message in a conversation
+   *
+   * @param conversationId - Conversation ID
+   * @param content - Message content
+   */
+  sendMessage(conversationId, content) {
+    if (!this.isConnected()) {
+      throw new Error("Not connected to AI chat");
+    }
+    this.accumulatedContent.set(conversationId, "");
+    const message = {
+      type: "message",
+      conversation_id: conversationId,
+      content
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Cancel an ongoing message generation
+   *
+   * @param conversationId - Conversation ID
+   */
+  cancel(conversationId) {
+    if (!this.isConnected()) {
+      throw new Error("Not connected to AI chat");
+    }
+    const message = {
+      type: "cancel",
+      conversation_id: conversationId
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * Get the full accumulated response content for a conversation
+   *
+   * @param conversationId - Conversation ID
+   * @returns Accumulated content string
+   */
+  getAccumulatedContent(conversationId) {
+    return this.accumulatedContent.get(conversationId) || "";
+  }
+  buildWsUrl() {
+    let url = this.options.wsUrl || "/ai/ws";
+    if (this.options.token) {
+      const separator = url.includes("?") ? "&" : "?";
+      url = `${url}${separator}token=${encodeURIComponent(this.options.token)}`;
+    }
+    return url;
+  }
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      const event = this.serverMessageToEvent(message);
+      switch (message.type) {
+        case "chat_started":
+          if (this.pendingStartResolve && message.conversation_id) {
+            this.pendingStartResolve(message.conversation_id);
+            this.pendingStartResolve = null;
+            this.pendingStartReject = null;
+          }
+          break;
+        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.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);
+          }
+          break;
+        case "query_result":
+          if (message.conversation_id) {
+            this.options.onQueryResult?.(
+              message.query || "",
+              message.summary || "",
+              message.row_count || 0,
+              message.data || [],
+              message.conversation_id
+            );
+          }
+          break;
+        case "done":
+          if (message.conversation_id) {
+            this.options.onDone?.(message.usage, message.conversation_id);
+          }
+          break;
+        case "error":
+          if (this.pendingStartReject) {
+            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);
+          break;
+      }
+      this.emitEvent(event);
+    } catch (error) {
+      console.error("Failed to parse AI chat message:", error);
+    }
+  }
+  serverMessageToEvent(message) {
+    return {
+      type: message.type,
+      conversationId: message.conversation_id,
+      chatbot: message.chatbot,
+      step: message.step,
+      message: message.message,
+      delta: message.delta,
+      query: message.query,
+      summary: message.summary,
+      rowCount: message.row_count,
+      data: message.data,
+      usage: message.usage,
+      error: message.error,
+      code: message.code
+    };
+  }
+  emitEvent(event) {
+    this.options.onEvent?.(event);
+  }
+  handleClose(_event) {
+    if (this.options.reconnectAttempts && this.reconnectCount < this.options.reconnectAttempts) {
+      this.reconnectCount++;
+      setTimeout(() => {
+        this.connect().catch(() => {
+        });
+      }, this.options.reconnectDelay);
+    }
+  }
+};
+var FluxbaseAI = class {
+  constructor(fetch2, wsBaseUrl) {
+    this.fetch = fetch2;
+    this.wsBaseUrl = wsBaseUrl;
+  }
+  /**
+   * List available chatbots (public, enabled)
+   *
+   * @returns Promise resolving to { data, error } tuple with array of chatbot summaries
+   */
+  async listChatbots() {
+    try {
+      const response = await this.fetch.get(
+        "/api/v1/ai/chatbots"
+      );
+      return { data: response.chatbots || [], error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get details of a specific chatbot
+   *
+   * @param id - Chatbot ID
+   * @returns Promise resolving to { data, error } tuple with chatbot details
+   */
+  async getChatbot(id) {
+    try {
+      const data = await this.fetch.get(`/api/v1/ai/chatbots/${id}`);
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Create a new AI chat connection
+   *
+   * @param options - Chat connection options
+   * @returns FluxbaseAIChat instance
+   */
+  createChat(options) {
+    return new FluxbaseAIChat({
+      ...options,
+      wsUrl: `${this.wsBaseUrl}/ai/ws`
+    });
+  }
+  /**
+   * List the authenticated user's conversations
+   *
+   * @param options - Optional filters and pagination
+   * @returns Promise resolving to { data, error } tuple with conversations
+   *
+   * @example
+   * ```typescript
+   * // List all conversations
+   * const { data, error } = await ai.listConversations()
+   *
+   * // Filter by chatbot
+   * const { data, error } = await ai.listConversations({ chatbot: 'sql-assistant' })
+   *
+   * // With pagination
+   * const { data, error } = await ai.listConversations({ limit: 20, offset: 0 })
+   * ```
+   */
+  async listConversations(options) {
+    try {
+      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));
+      const queryString = params.toString();
+      const path = `/api/v1/ai/conversations${queryString ? `?${queryString}` : ""}`;
+      const response = await this.fetch.get(path);
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Get a single conversation with all messages
+   *
+   * @param id - Conversation ID
+   * @returns Promise resolving to { data, error } tuple with conversation detail
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await ai.getConversation('conv-uuid-123')
+   * if (data) {
+   *   console.log(`Title: ${data.title}`)
+   *   console.log(`Messages: ${data.messages.length}`)
+   * }
+   * ```
+   */
+  async getConversation(id) {
+    try {
+      const response = await this.fetch.get(
+        `/api/v1/ai/conversations/${id}`
+      );
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Delete a conversation
+   *
+   * @param id - Conversation ID
+   * @returns Promise resolving to { error } (null on success)
+   *
+   * @example
+   * ```typescript
+   * const { error } = await ai.deleteConversation('conv-uuid-123')
+   * if (!error) {
+   *   console.log('Conversation deleted')
+   * }
+   * ```
+   */
+  async deleteConversation(id) {
+    try {
+      await this.fetch.delete(`/api/v1/ai/conversations/${id}`);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  /**
+   * Update a conversation (currently supports title update only)
+   *
+   * @param id - Conversation ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated conversation
    *
    * @example
    * ```typescript
-   * await admin.deleteUser('user-uuid');
-   * console.log('User deleted');
+   * const { data, error } = await ai.updateConversation('conv-uuid-123', {
+   *   title: 'My custom conversation title'
+   * })
    * ```
    */
-  async deleteUser(userId, type = "app") {
-    return wrapAsync(async () => {
-      const url = `/api/v1/admin/users/${userId}?type=${type}`;
-      return await this.fetch.delete(url);
-    });
+  async updateConversation(id, updates) {
+    try {
+      const response = await this.fetch.patch(
+        `/api/v1/ai/conversations/${id}`,
+        updates
+      );
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+};
+
+// src/vector.ts
+var FluxbaseVector = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
   }
   /**
-   * Update user role
-   *
-   * Changes a user's role
-   *
-   * @param userId - User ID
-   * @param role - New role
-   * @param type - User type ('app' or 'dashboard')
-   * @returns Updated user
+   * Generate embeddings for text
    *
    * @example
    * ```typescript
-   * const user = await admin.updateUserRole('user-uuid', 'admin');
-   * console.log('User role updated:', user.role);
+   * // Single text
+   * const { data } = await client.vector.embed({
+   *   text: 'Hello world'
+   * })
+   * console.log(data.embeddings[0]) // [0.1, 0.2, ...]
+   *
+   * // Multiple texts
+   * const { data } = await client.vector.embed({
+   *   texts: ['Hello', 'World'],
+   *   model: 'text-embedding-3-small'
+   * })
    * ```
    */
-  async updateUserRole(userId, role, type = "app") {
-    return wrapAsync(async () => {
-      const url = `/api/v1/admin/users/${userId}/role?type=${type}`;
-      return await this.fetch.patch(url, { role });
-    });
+  async embed(request) {
+    try {
+      const response = await this.fetch.request(
+        "/api/v1/vector/embed",
+        {
+          method: "POST",
+          body: request
+        }
+      );
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
   }
   /**
-   * Reset user password
+   * Search for similar vectors with automatic text embedding
    *
-   * Generates a new password for the user and optionally sends it via email
-   *
-   * @param userId - User ID
-   * @param type - User type ('app' or 'dashboard')
-   * @returns Reset confirmation message
+   * This is a convenience method that:
+   * 1. Embeds the query text automatically (if `query` is provided)
+   * 2. Performs vector similarity search
+   * 3. Returns results with distance scores
    *
    * @example
    * ```typescript
-   * const response = await admin.resetUserPassword('user-uuid');
-   * console.log(response.message);
+   * // Search with text query (auto-embedded)
+   * const { data } = await client.vector.search({
+   *   table: 'documents',
+   *   column: 'embedding',
+   *   query: 'How to use TypeScript?',
+   *   match_count: 10,
+   *   match_threshold: 0.8
+   * })
+   *
+   * // Search with pre-computed vector
+   * const { data } = await client.vector.search({
+   *   table: 'documents',
+   *   column: 'embedding',
+   *   vector: [0.1, 0.2, ...],
+   *   metric: 'cosine',
+   *   match_count: 10
+   * })
+   *
+   * // With additional filters
+   * const { data } = await client.vector.search({
+   *   table: 'documents',
+   *   column: 'embedding',
+   *   query: 'TypeScript tutorial',
+   *   filters: [
+   *     { column: 'status', operator: 'eq', value: 'published' }
+   *   ],
+   *   match_count: 10
+   * })
    * ```
    */
-  async resetUserPassword(userId, type = "app") {
-    return wrapAsync(async () => {
-      const url = `/api/v1/admin/users/${userId}/reset-password?type=${type}`;
-      return await this.fetch.post(url, {});
-    });
+  async search(options) {
+    try {
+      const response = await this.fetch.request(
+        "/api/v1/vector/search",
+        {
+          method: "POST",
+          body: {
+            table: options.table,
+            column: options.column,
+            query: options.query,
+            vector: options.vector,
+            metric: options.metric || "cosine",
+            match_threshold: options.match_threshold,
+            match_count: options.match_count,
+            select: options.select,
+            filters: options.filters
+          }
+        }
+      );
+      return { data: response, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
   }
 };
 
 // src/query-builder.ts
+var URL_LENGTH_THRESHOLD = 4096;
 var QueryBuilder = class {
   constructor(fetch2, table, schema) {
     this.selectQuery = "*";
     this.filters = [];
     this.orFilters = [];
     this.andFilters = [];
+    this.betweenFilters = [];
     this.orderBys = [];
     this.singleRow = false;
     this.maybeSingleRow = false;
     this.operationType = "select";
     this.headOnly = false;
+    this.isCountAggregation = false;
     this.fetch = fetch2;
     this.table = table;
     this.schema = schema;
@@ -6359,8 +9044,20 @@ var QueryBuilder = class {
    * Generic filter method using PostgREST syntax (Supabase-compatible)
    * @example filter('name', 'in', '("Han","Yoda")')
    * @example filter('age', 'gte', '18')
+   * @example filter('recorded_at', 'between', ['2024-01-01', '2024-01-10'])
+   * @example filter('recorded_at', 'not.between', ['2024-01-01', '2024-01-10'])
    */
   filter(column, operator, value) {
+    if (operator === "between" || operator === "not.between") {
+      const [min, max] = this.validateBetweenValue(value, operator);
+      this.betweenFilters.push({
+        column,
+        min,
+        max,
+        negated: operator === "not.between"
+      });
+      return this;
+    }
     this.filters.push({ column, operator, value });
     return this;
   }
@@ -6381,6 +9078,33 @@ var QueryBuilder = class {
     this.filters.push({ column, operator: "ov", value });
     return this;
   }
+  /**
+   * Filter column value within an inclusive range (BETWEEN)
+   * Generates: AND (column >= min AND column <= max)
+   *
+   * @param column - Column name to filter
+   * @param min - Minimum value (inclusive)
+   * @param max - Maximum value (inclusive)
+   * @example between('recorded_at', '2024-01-01', '2024-01-10')
+   * @example between('price', 10, 100)
+   */
+  between(column, min, max) {
+    return this.filter(column, "between", [min, max]);
+  }
+  /**
+   * Filter column value outside an inclusive range (NOT BETWEEN)
+   * Generates: OR (column < min OR column > max)
+   * Multiple notBetween calls on the same column AND together
+   *
+   * @param column - Column name to filter
+   * @param min - Minimum value of excluded range
+   * @param max - Maximum value of excluded range
+   * @example notBetween('recorded_at', '2024-01-01', '2024-01-10')
+   * @example notBetween('price', 0, 10) // Excludes items priced 0-10
+   */
+  notBetween(column, min, max) {
+    return this.filter(column, "not.between", [min, max]);
+  }
   // PostGIS Spatial Query Methods
   /**
    * Check if geometries intersect (PostGIS ST_Intersects)
@@ -6477,6 +9201,80 @@ var QueryBuilder = class {
     });
     return this;
   }
+  /**
+   * Order results by vector similarity (pgvector)
+   * Results are ordered by distance (ascending = closest first)
+   *
+   * @example
+   * ```typescript
+   * // Order by cosine similarity (closest matches first)
+   * const { data } = await client
+   *   .from('documents')
+   *   .select('id, title, content')
+   *   .orderByVector('embedding', queryVector, 'cosine')
+   *   .limit(10)
+   * ```
+   *
+   * @param column - The vector column to order by
+   * @param vector - The query vector to compare against
+   * @param metric - Distance metric: 'l2' (euclidean), 'cosine', or 'inner_product'
+   * @param options - Optional: { ascending?: boolean } - defaults to true (closest first)
+   */
+  orderByVector(column, vector, metric = "cosine", options) {
+    const opMap = {
+      l2: "vec_l2",
+      cosine: "vec_cos",
+      inner_product: "vec_ip"
+    };
+    this.orderBys.push({
+      column,
+      direction: options?.ascending === false ? "desc" : "asc",
+      vectorOp: opMap[metric],
+      vectorValue: vector
+    });
+    return this;
+  }
+  /**
+   * Filter by vector similarity (pgvector)
+   * This is a convenience method that adds a vector filter using the specified distance metric.
+   * Typically used with orderByVector() for similarity search.
+   *
+   * @example
+   * ```typescript
+   * // Find the 10 most similar documents
+   * const { data } = await client
+   *   .from('documents')
+   *   .select('id, title, content')
+   *   .vectorSearch('embedding', queryVector, 'cosine')
+   *   .limit(10)
+   *
+   * // Combine with other filters
+   * const { data } = await client
+   *   .from('documents')
+   *   .select('id, title, content')
+   *   .eq('status', 'published')
+   *   .vectorSearch('embedding', queryVector)
+   *   .limit(10)
+   * ```
+   *
+   * @param column - The vector column to search
+   * @param vector - The query vector
+   * @param metric - Distance metric: 'l2' (euclidean), 'cosine', or 'inner_product'
+   */
+  vectorSearch(column, vector, metric = "cosine") {
+    const opMap = {
+      l2: "vec_l2",
+      cosine: "vec_cos",
+      inner_product: "vec_ip"
+    };
+    this.filters.push({
+      column,
+      operator: opMap[metric],
+      value: vector
+    });
+    this.orderByVector(column, vector, metric, { ascending: true });
+    return this;
+  }
   /**
    * Limit number of rows returned
    */
@@ -6581,6 +9379,7 @@ var QueryBuilder = class {
    */
   count(column = "*") {
     this.selectQuery = `count(${column})`;
+    this.isCountAggregation = true;
     return this;
   }
   /**
@@ -6801,6 +9600,9 @@ var QueryBuilder = class {
           statusText: "No Content"
         };
       }
+      if (this.shouldUsePostQuery()) {
+        return this.executePostQuery();
+      }
       const queryString = this.buildQueryString();
       const path = `${this.buildTablePath()}${queryString}`;
       if (this.countType) {
@@ -6863,6 +9665,29 @@ var QueryBuilder = class {
         };
       }
       const data = await this.fetch.get(path);
+      if (this.isCountAggregation && !this.groupByColumns) {
+        if (Array.isArray(data) && data.length === 1) {
+          const countData = data[0];
+          if (countData && typeof countData.count === "number") {
+            return {
+              data,
+              error: null,
+              count: countData.count,
+              status: 200,
+              statusText: "OK"
+            };
+          }
+        }
+        if (Array.isArray(data) && data.length === 0) {
+          return {
+            data,
+            error: null,
+            count: 0,
+            status: 200,
+            statusText: "OK"
+          };
+        }
+      }
       if (this.singleRow) {
         if (Array.isArray(data) && data.length === 0) {
           return {
@@ -6983,8 +9808,28 @@ var QueryBuilder = class {
         `${filter.operator}.${this.formatValue(filter.value)}`
       );
     }
+    const orExpressions = [];
     for (const orFilter of this.orFilters) {
-      params.append("or", `(${orFilter})`);
+      orExpressions.push(`or(${orFilter})`);
+    }
+    for (const bf of this.betweenFilters) {
+      const minFormatted = this.formatValue(bf.min);
+      const maxFormatted = this.formatValue(bf.max);
+      if (bf.negated) {
+        orExpressions.push(
+          `or(${bf.column}.lt.${minFormatted},${bf.column}.gt.${maxFormatted})`
+        );
+      } else {
+        params.append(bf.column, `gte.${minFormatted}`);
+        params.append(bf.column, `lte.${maxFormatted}`);
+      }
+    }
+    if (orExpressions.length === 1) {
+      const expr = orExpressions[0];
+      const inner = expr.replace(/^or\(/, "(");
+      params.append("or", inner);
+    } else if (orExpressions.length > 1) {
+      params.append("and", `(${orExpressions.join(",")})`);
     }
     for (const andFilter of this.andFilters) {
       params.append("and", `(${andFilter})`);
@@ -6993,9 +9838,13 @@ var QueryBuilder = class {
       params.append("group_by", this.groupByColumns.join(","));
     }
     if (this.orderBys.length > 0) {
-      const orderStr = this.orderBys.map(
-        (o) => `${o.column}.${o.direction}${o.nulls ? `.nulls${o.nulls}` : ""}`
-      ).join(",");
+      const orderStr = this.orderBys.map((o) => {
+        if (o.vectorOp && o.vectorValue) {
+          const vectorStr = `[${o.vectorValue.join(",")}]`;
+          return `${o.column}.${o.vectorOp}.${vectorStr}.${o.direction}`;
+        }
+        return `${o.column}.${o.direction}${o.nulls ? `.nulls${o.nulls}` : ""}`;
+      }).join(",");
       params.append("order", orderStr);
     }
     if (this.limitValue !== void 0) {
@@ -7028,6 +9877,34 @@ var QueryBuilder = class {
     }
     return String(value);
   }
+  /**
+   * Validate between filter value - must be array of exactly 2 elements
+   * @throws Error if value is invalid
+   */
+  validateBetweenValue(value, operator) {
+    if (!Array.isArray(value)) {
+      throw new Error(
+        `Invalid value for '${operator}' operator: expected array of [min, max], got ${typeof value}`
+      );
+    }
+    if (value.length !== 2) {
+      throw new Error(
+        `Invalid value for '${operator}' operator: expected array with exactly 2 elements [min, max], got ${value.length} elements`
+      );
+    }
+    const [min, max] = value;
+    if (min === null || min === void 0) {
+      throw new Error(
+        `Invalid value for '${operator}' operator: min value cannot be null or undefined`
+      );
+    }
+    if (max === null || max === void 0) {
+      throw new Error(
+        `Invalid value for '${operator}' operator: max value cannot be null or undefined`
+      );
+    }
+    return [min, max];
+  }
   /**
    * Parse the Content-Range header to extract the total count
    * Header format: "0-999/50000" or "* /50000" (when no rows returned)
@@ -7043,6 +9920,160 @@ var QueryBuilder = class {
     }
     return null;
   }
+  /**
+   * Check if the query should use POST-based query endpoint
+   * Returns true if the query string would exceed the URL length threshold
+   */
+  shouldUsePostQuery() {
+    const queryString = this.buildQueryString();
+    return queryString.length > URL_LENGTH_THRESHOLD;
+  }
+  /**
+   * Execute a SELECT query using the POST /query endpoint
+   * Used when query parameters would exceed URL length limits
+   */
+  async executePostQuery() {
+    const body = this.buildQueryBody();
+    const path = `${this.buildTablePath()}/query`;
+    if (this.countType) {
+      const response = await this.fetch.postWithHeaders(path, body);
+      const serverCount = this.parseContentRangeCount(response.headers);
+      const data2 = response.data;
+      if (this.headOnly) {
+        return {
+          data: null,
+          error: null,
+          count: serverCount,
+          status: response.status,
+          statusText: "OK"
+        };
+      }
+      if (this.singleRow) {
+        if (Array.isArray(data2) && data2.length === 0) {
+          return {
+            data: null,
+            error: { message: "No rows found", code: "PGRST116" },
+            count: serverCount ?? 0,
+            status: 404,
+            statusText: "Not Found"
+          };
+        }
+        const singleData = Array.isArray(data2) ? data2[0] : data2;
+        return {
+          data: singleData,
+          error: null,
+          count: serverCount ?? 1,
+          status: 200,
+          statusText: "OK"
+        };
+      }
+      if (this.maybeSingleRow) {
+        if (Array.isArray(data2) && data2.length === 0) {
+          return {
+            data: null,
+            error: null,
+            count: serverCount ?? 0,
+            status: 200,
+            statusText: "OK"
+          };
+        }
+        const singleData = Array.isArray(data2) ? data2[0] : data2;
+        return {
+          data: singleData,
+          error: null,
+          count: serverCount ?? 1,
+          status: 200,
+          statusText: "OK"
+        };
+      }
+      return {
+        data: data2,
+        error: null,
+        count: serverCount ?? (Array.isArray(data2) ? data2.length : null),
+        status: 200,
+        statusText: "OK"
+      };
+    }
+    const data = await this.fetch.post(path, body);
+    if (this.singleRow) {
+      if (Array.isArray(data) && data.length === 0) {
+        return {
+          data: null,
+          error: { message: "No rows found", code: "PGRST116" },
+          count: 0,
+          status: 404,
+          statusText: "Not Found"
+        };
+      }
+      const singleData = Array.isArray(data) ? data[0] : data;
+      return {
+        data: singleData,
+        error: null,
+        count: 1,
+        status: 200,
+        statusText: "OK"
+      };
+    }
+    if (this.maybeSingleRow) {
+      if (Array.isArray(data) && data.length === 0) {
+        return {
+          data: null,
+          error: null,
+          count: 0,
+          status: 200,
+          statusText: "OK"
+        };
+      }
+      const singleData = Array.isArray(data) ? data[0] : data;
+      return {
+        data: singleData,
+        error: null,
+        count: 1,
+        status: 200,
+        statusText: "OK"
+      };
+    }
+    return {
+      data,
+      error: null,
+      count: Array.isArray(data) ? data.length : null,
+      status: 200,
+      statusText: "OK"
+    };
+  }
+  /**
+   * Build the request body for POST-based queries
+   * Used when query parameters would exceed URL length limits
+   */
+  buildQueryBody() {
+    return {
+      select: this.selectQuery !== "*" ? this.selectQuery : void 0,
+      filters: this.filters.map((f) => ({
+        column: f.column,
+        operator: f.operator,
+        value: f.value
+      })),
+      orFilters: this.orFilters,
+      andFilters: this.andFilters,
+      betweenFilters: this.betweenFilters.map((bf) => ({
+        column: bf.column,
+        min: bf.min,
+        max: bf.max,
+        negated: bf.negated
+      })),
+      order: this.orderBys.map((o) => ({
+        column: o.column,
+        direction: o.direction,
+        nulls: o.nulls,
+        vectorOp: o.vectorOp,
+        vectorValue: o.vectorValue
+      })),
+      limit: this.limitValue,
+      offset: this.offsetValue,
+      count: this.countType,
+      groupBy: this.groupByColumns
+    };
+  }
 };
 
 // src/schema-query-builder.ts
@@ -7112,6 +10143,26 @@ var FluxbaseClient = class {
     this.admin = new FluxbaseAdmin(this.fetch);
     this.management = new FluxbaseManagement(this.fetch);
     this.settings = new SettingsClient(this.fetch);
+    const wsProtocol = fluxbaseUrl.startsWith("https") ? "wss" : "ws";
+    const wsBaseUrl = fluxbaseUrl.replace(/^https?:/, wsProtocol + ":");
+    this.ai = new FluxbaseAI(this.fetch, wsBaseUrl);
+    this.vector = new FluxbaseVector(this.fetch);
+    const rpcInstance = new FluxbaseRPC(this.fetch);
+    const rpcCallable = async (fn, params) => {
+      const result = await rpcInstance.invoke(fn, params);
+      return {
+        data: result.data?.result ?? null,
+        error: result.error
+      };
+    };
+    Object.assign(rpcCallable, {
+      invoke: rpcInstance.invoke.bind(rpcInstance),
+      list: rpcInstance.list.bind(rpcInstance),
+      getStatus: rpcInstance.getStatus.bind(rpcInstance),
+      getLogs: rpcInstance.getLogs.bind(rpcInstance),
+      waitForCompletion: rpcInstance.waitForCompletion.bind(rpcInstance)
+    });
+    this.rpc = rpcCallable;
     this.setupAuthSync();
   }
   /**
@@ -7151,12 +10202,12 @@ var FluxbaseClient = class {
    *
    * @example
    * ```typescript
-   * // Query the jobs.execution_logs table
+   * // Query the logging.entries table
    * const { data } = await client
-   *   .schema('jobs')
-   *   .from('execution_logs')
+   *   .schema('logging')
+   *   .from('entries')
    *   .select('*')
-   *   .eq('job_id', jobId)
+   *   .eq('execution_id', executionId)
    *   .execute()
    *
    * // Insert into a custom schema table
@@ -7172,38 +10223,6 @@ var FluxbaseClient = class {
   schema(schemaName) {
     return new SchemaQueryBuilder(this.fetch, schemaName);
   }
-  /**
-   * Call a PostgreSQL function (Remote Procedure Call)
-   *
-   * @param functionName - The name of the PostgreSQL function to call
-   * @param params - Optional parameters to pass to the function
-   * @returns Promise containing the function result or error
-   *
-   * @example
-   * ```typescript
-   * // Call a function without parameters
-   * const { data, error } = await client.rpc('get_total_users')
-   *
-   * // Call a function with parameters
-   * const { data, error } = await client.rpc('calculate_discount', {
-   *   product_id: 123,
-   *   coupon_code: 'SAVE20'
-   * })
-   * ```
-   *
-   * @category Database
-   */
-  async rpc(functionName, params) {
-    try {
-      const data = await this.fetch.post(
-        `/api/v1/rpc/${functionName}`,
-        params || {}
-      );
-      return { data, error: null };
-    } catch (error) {
-      return { data: null, error };
-    }
-  }
   /**
    * Sync auth state with realtime connections
    * @internal
@@ -7217,7 +10236,10 @@ var FluxbaseClient = class {
     this.realtime.setTokenRefreshCallback(async () => {
       const result = await this.auth.refreshSession();
       if (result.error || !result.data?.session) {
-        console.error("[Fluxbase] Failed to refresh token for realtime:", result.error);
+        console.error(
+          "[Fluxbase] Failed to refresh token for realtime:",
+          result.error
+        );
         return null;
       }
       return result.data.session.access_token;
@@ -7336,10 +10358,16 @@ exports.AppSettingsManager = AppSettingsManager;
 exports.AuthSettingsManager = AuthSettingsManager;
 exports.DDLManager = DDLManager;
 exports.EmailTemplateManager = EmailTemplateManager;
+exports.ExecutionLogsChannel = ExecutionLogsChannel;
+exports.FluxbaseAI = FluxbaseAI;
+exports.FluxbaseAIChat = FluxbaseAIChat;
 exports.FluxbaseAdmin = FluxbaseAdmin;
+exports.FluxbaseAdminAI = FluxbaseAdminAI;
 exports.FluxbaseAdminFunctions = FluxbaseAdminFunctions;
 exports.FluxbaseAdminJobs = FluxbaseAdminJobs;
 exports.FluxbaseAdminMigrations = FluxbaseAdminMigrations;
+exports.FluxbaseAdminRPC = FluxbaseAdminRPC;
+exports.FluxbaseAdminStorage = FluxbaseAdminStorage;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
@@ -7347,9 +10375,11 @@ exports.FluxbaseFunctions = FluxbaseFunctions;
 exports.FluxbaseJobs = FluxbaseJobs;
 exports.FluxbaseManagement = FluxbaseManagement;
 exports.FluxbaseOAuth = FluxbaseOAuth;
+exports.FluxbaseRPC = FluxbaseRPC;
 exports.FluxbaseRealtime = FluxbaseRealtime;
 exports.FluxbaseSettings = FluxbaseSettings;
 exports.FluxbaseStorage = FluxbaseStorage;
+exports.FluxbaseVector = FluxbaseVector;
 exports.ImpersonationManager = ImpersonationManager;
 exports.InvitationsManager = InvitationsManager;
 exports.OAuthProviderManager = OAuthProviderManager;
@@ -7360,6 +10390,9 @@ exports.SettingsClient = SettingsClient;
 exports.StorageBucket = StorageBucket;
 exports.SystemSettingsManager = SystemSettingsManager;
 exports.WebhooksManager = WebhooksManager;
+exports.bundleCode = bundleCode;
 exports.createClient = createClient;
+exports.denoExternalPlugin = denoExternalPlugin;
+exports.loadImportMap = loadImportMap;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map