@fluxbase/sdk 0.0.1-rc.48 → 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
@@ -2266,6 +2438,282 @@ var StorageBucket = class {
       return { data: null, error };
     }
   }
+  /**
+   * 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 uploadResumable(path, file, options) {
+    try {
+      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 {
+        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 || [];
+      }
+      let uploadedBytes = 0;
+      for (const chunkIdx of completedChunks) {
+        const chunkStart = chunkIdx * chunkSize;
+        const chunkEnd = Math.min(chunkStart + chunkSize, totalSize);
+        uploadedBytes += chunkEnd - chunkStart;
+      }
+      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
+          });
+        }
+      }
+      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 result = await completeResponse.json();
+      return {
+        data: {
+          id: result.id,
+          path: result.path,
+          fullPath: result.full_path
+        },
+        error: null
+      };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Abort an in-progress resumable upload
+   * @param sessionId - The upload session ID to abort
+   */
+  async abortResumableUpload(sessionId) {
+    try {
+      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)
@@ -2837,40 +3285,244 @@ var FluxbaseJobs = class {
       return { data: null, error };
     }
   }
-};
-
-// src/settings.ts
-var SystemSettingsManager = class {
-  constructor(fetch2) {
-    this.fetch = fetch2;
-  }
   /**
-   * List all system settings
+   * Get execution logs for a job
    *
-   * @returns Promise resolving to ListSystemSettingsResponse
+   * 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
-   * const response = await client.admin.settings.system.list()
-   * console.log(response.settings)
-   * ```
-   */
-  async list() {
-    const settings = await this.fetch.get(
-      "/api/v1/admin/system/settings"
-    );
-    return { settings: Array.isArray(settings) ? settings : [] };
-  }
-  /**
-   * Get a specific system setting by key
+   * // Get all logs for a job
+   * const { data: logs, error } = await client.jobs.getLogs('550e8400-e29b-41d4-a716-446655440000')
    *
-   * @param key - Setting key (e.g., 'app.auth.enable_signup')
-   * @returns Promise resolving to SystemSetting
+   * if (logs) {
+   *   for (const log of logs) {
+   *     console.log(`[${log.level}] ${log.message}`)
+   *   }
+   * }
    *
-   * @example
-   * ```typescript
-   * const setting = await client.admin.settings.system.get('app.auth.enable_signup')
-   * console.log(setting.value)
+   * // 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
+var SystemSettingsManager = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * List all system settings
+   *
+   * @returns Promise resolving to ListSystemSettingsResponse
+   *
+   * @example
+   * ```typescript
+   * const response = await client.admin.settings.system.list()
+   * console.log(response.settings)
+   * ```
+   */
+  async list() {
+    const settings = await this.fetch.get(
+      "/api/v1/admin/system/settings"
+    );
+    return { settings: Array.isArray(settings) ? settings : [] };
+  }
+  /**
+   * Get a specific system setting by key
+   *
+   * @param key - Setting key (e.g., 'app.auth.enable_signup')
+   * @returns Promise resolving to SystemSetting
+   *
+   * @example
+   * ```typescript
+   * const setting = await client.admin.settings.system.get('app.auth.enable_signup')
+   * console.log(setting.value)
    * ```
    */
   async get(key) {
@@ -5193,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
@@ -5342,9 +5956,9 @@ var FluxbaseAdminMigrations = class {
       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) {
@@ -5377,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 };
@@ -5478,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 };
@@ -5579,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()}`
       );
@@ -6379,39 +7001,444 @@ var FluxbaseAdminAI = class {
       return { data: null, error };
     }
   }
-};
-
-// src/admin-rpc.ts
-var FluxbaseAdminRPC = class {
-  constructor(fetch2) {
-    this.fetch = fetch2;
-  }
   // ============================================================================
-  // PROCEDURE MANAGEMENT
+  // KNOWLEDGE BASE MANAGEMENT (RAG)
   // ============================================================================
   /**
-   * 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.
+   * List all knowledge bases
    *
-   * @param options - Sync options including namespace and optional procedures array
-   * @returns Promise resolving to { data, error } tuple with sync results
+   * @returns Promise resolving to { data, error } tuple with array of knowledge base summaries
    *
    * @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,
+   * 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
@@ -6697,6 +7724,230 @@ var FluxbaseAdminRPC = class {
   }
 };
 
+// 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) {
@@ -6713,6 +7964,7 @@ var FluxbaseAdmin = class {
     this.migrations = new FluxbaseAdminMigrations(fetch2);
     this.ai = new FluxbaseAdminAI(fetch2);
     this.rpc = new FluxbaseAdminRPC(fetch2);
+    this.storage = new FluxbaseAdminStorage(fetch2);
   }
   /**
    * Set admin authentication token
@@ -6735,6 +7987,54 @@ var FluxbaseAdmin = class {
     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
   // ============================================================================
   /**
@@ -7412,7 +8712,111 @@ var FluxbaseAI = class {
   }
 };
 
+// src/vector.ts
+var FluxbaseVector = class {
+  constructor(fetch2) {
+    this.fetch = fetch2;
+  }
+  /**
+   * Generate embeddings for text
+   *
+   * @example
+   * ```typescript
+   * // 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 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 };
+    }
+  }
+  /**
+   * Search for similar vectors with automatic text embedding
+   *
+   * 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
+   * // 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 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 = "*";
@@ -7425,6 +8829,7 @@ var QueryBuilder = class {
     this.maybeSingleRow = false;
     this.operationType = "select";
     this.headOnly = false;
+    this.isCountAggregation = false;
     this.fetch = fetch2;
     this.table = table;
     this.schema = schema;
@@ -7796,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
    */
@@ -7900,6 +9379,7 @@ var QueryBuilder = class {
    */
   count(column = "*") {
     this.selectQuery = `count(${column})`;
+    this.isCountAggregation = true;
     return this;
   }
   /**
@@ -8120,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) {
@@ -8181,7 +9664,30 @@ var QueryBuilder = class {
           statusText: "OK"
         };
       }
-      const data = await this.fetch.get(path);
+      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 {
@@ -8302,32 +9808,43 @@ var QueryBuilder = class {
         `${filter.operator}.${this.formatValue(filter.value)}`
       );
     }
+    const orExpressions = [];
     for (const orFilter of this.orFilters) {
-      params.append("or", `(${orFilter})`);
-    }
-    for (const andFilter of this.andFilters) {
-      params.append("and", `(${andFilter})`);
+      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) {
-        params.append(
-          "or",
-          `(${bf.column}.lt.${minFormatted},${bf.column}.gt.${maxFormatted})`
+        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})`);
+    }
     if (this.groupByColumns && this.groupByColumns.length > 0) {
       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) {
@@ -8403,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
@@ -8475,6 +10146,23 @@ var FluxbaseClient = class {
     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();
   }
   /**
@@ -8514,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
@@ -8548,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;
@@ -8662,168 +10353,12 @@ function createClient(fluxbaseUrl, fluxbaseKey, options) {
   return new FluxbaseClient(url, key, options);
 }
 
-// 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") };
-  }
-};
-
 exports.APIKeysManager = APIKeysManager;
 exports.AppSettingsManager = AppSettingsManager;
 exports.AuthSettingsManager = AuthSettingsManager;
 exports.DDLManager = DDLManager;
 exports.EmailTemplateManager = EmailTemplateManager;
+exports.ExecutionLogsChannel = ExecutionLogsChannel;
 exports.FluxbaseAI = FluxbaseAI;
 exports.FluxbaseAIChat = FluxbaseAIChat;
 exports.FluxbaseAdmin = FluxbaseAdmin;
@@ -8832,6 +10367,7 @@ exports.FluxbaseAdminFunctions = FluxbaseAdminFunctions;
 exports.FluxbaseAdminJobs = FluxbaseAdminJobs;
 exports.FluxbaseAdminMigrations = FluxbaseAdminMigrations;
 exports.FluxbaseAdminRPC = FluxbaseAdminRPC;
+exports.FluxbaseAdminStorage = FluxbaseAdminStorage;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
@@ -8843,6 +10379,7 @@ exports.FluxbaseRPC = FluxbaseRPC;
 exports.FluxbaseRealtime = FluxbaseRealtime;
 exports.FluxbaseSettings = FluxbaseSettings;
 exports.FluxbaseStorage = FluxbaseStorage;
+exports.FluxbaseVector = FluxbaseVector;
 exports.ImpersonationManager = ImpersonationManager;
 exports.InvitationsManager = InvitationsManager;
 exports.OAuthProviderManager = OAuthProviderManager;