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

package/dist/index.cjs

@@ -1919,6 +1919,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();
@@ -2550,7 +2671,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 +2697,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 +2712,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 };
@@ -3270,11 +3402,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 +3420,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 +4658,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,6 +5034,111 @@ var FluxbaseAdminFunctions = class {
       return { data: null, error };
     }
   }
+  /**
+   * Sync edge functions with automatic client-side bundling
+   *
+   * This is a convenience method that bundles all function code using esbuild
+   * before sending to the server. Requires esbuild as a peer dependency.
+   *
+   * @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
+   * 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
@@ -4962,8 +5339,8 @@ 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();
         } catch (refreshError) {
@@ -5214,16 +5591,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,149 +6075,688 @@ 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 };
+    }
+  }
+  /**
+   * Get details of a specific chatbot
+   *
+   * @param id - Chatbot ID
+   * @returns Promise resolving to { data, error } tuple with chatbot details
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.getChatbot('uuid')
+   * if (data) {
+   *   console.log('Chatbot:', data.name)
+   * }
+   * ```
+   */
+  async getChatbot(id) {
+    try {
+      const data = await this.fetch.get(
+        `/api/v1/admin/ai/chatbots/${id}`
+      );
+      return { data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  /**
+   * Enable or disable a chatbot
+   *
+   * @param id - Chatbot ID
+   * @param enabled - Whether to enable or disable
+   * @returns Promise resolving to { data, error } tuple with updated chatbot
+   *
+   * @example
+   * ```typescript
+   * const { data, error } = await client.admin.ai.toggleChatbot('uuid', true)
+   * ```
+   */
+  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 };
+    }
+  }
+};
+
+// 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.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);
+  }
+  /**
+   * 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
+  // ============================================================================
+  /**
+   * 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
    *
@@ -6015,121 +6921,494 @@ var FluxbaseAdmin = class {
     });
   }
   /**
-   * Get a user by ID
-   *
-   * Fetch a single user's details by their user ID
+   * Get a user by ID
+   *
+   * Fetch a single user's details by their user ID
+   *
+   * @param userId - User ID to fetch
+   * @param type - User type ('app' or 'dashboard')
+   * @returns User details with metadata
+   *
+   * @example
+   * ```typescript
+   * // Get an app user
+   * const user = await admin.getUserById('user-123');
+   *
+   * // Get a dashboard user
+   * const dashboardUser = await admin.getUserById('admin-456', 'dashboard');
+   * console.log('User email:', dashboardUser.email);
+   * console.log('Last login:', dashboardUser.last_login_at);
+   * ```
+   */
+  async getUserById(userId, type = "app") {
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/${userId}?type=${type}`;
+      return await this.fetch.get(url);
+    });
+  }
+  /**
+   * Invite a new user
+   *
+   * Creates a new user and optionally sends an invitation email
+   *
+   * @param request - User invitation details
+   * @param type - User type ('app' or 'dashboard')
+   * @returns Created user and invitation details
+   *
+   * @example
+   * ```typescript
+   * const response = await admin.inviteUser({
+   *   email: 'newuser@example.com',
+   *   role: 'user',
+   *   send_email: true
+   * });
+   *
+   * console.log('User invited:', response.user.email);
+   * console.log('Invitation link:', response.invitation_link);
+   * ```
+   */
+  async inviteUser(request, type = "app") {
+    return wrapAsync(async () => {
+      const url = `/api/v1/admin/users/invite?type=${type}`;
+      return await this.fetch.post(url, request);
+    });
+  }
+  /**
+   * Delete a user
+   *
+   * Permanently deletes a user and all associated data
+   *
+   * @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)
    *
-   * @param userId - User ID to fetch
-   * @param type - User type ('app' or 'dashboard')
-   * @returns User details with metadata
+   * @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
    *
-   * @example
-   * ```typescript
-   * // Get an app user
-   * const user = await admin.getUserById('user-123');
+   * @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
    *
-   * // Get a dashboard user
-   * const dashboardUser = await admin.getUserById('admin-456', 'dashboard');
-   * console.log('User email:', dashboardUser.email);
-   * console.log('Last login:', dashboardUser.last_login_at);
-   * ```
+   * @param options - Chat connection options
+   * @returns FluxbaseAIChat instance
    */
-  async getUserById(userId, type = "app") {
-    return wrapAsync(async () => {
-      const url = `/api/v1/admin/users/${userId}?type=${type}`;
-      return await this.fetch.get(url);
+  createChat(options) {
+    return new FluxbaseAIChat({
+      ...options,
+      wsUrl: `${this.wsBaseUrl}/ai/ws`
     });
   }
   /**
-   * Invite a new user
-   *
-   * Creates a new user and optionally sends an invitation email
+   * List the authenticated user's conversations
    *
-   * @param request - User invitation details
-   * @param type - User type ('app' or 'dashboard')
-   * @returns Created user and invitation details
+   * @param options - Optional filters and pagination
+   * @returns Promise resolving to { data, error } tuple with conversations
    *
    * @example
    * ```typescript
-   * const response = await admin.inviteUser({
-   *   email: 'newuser@example.com',
-   *   role: 'user',
-   *   send_email: true
-   * });
+   * // List all conversations
+   * const { data, error } = await ai.listConversations()
    *
-   * console.log('User invited:', response.user.email);
-   * console.log('Invitation link:', response.invitation_link);
+   * // 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 inviteUser(request, type = "app") {
-    return wrapAsync(async () => {
-      const url = `/api/v1/admin/users/invite?type=${type}`;
-      return await this.fetch.post(url, request);
-    });
+  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 };
+    }
   }
   /**
-   * Delete a user
-   *
-   * Permanently deletes a user and all associated data
+   * Get a single conversation with all messages
    *
-   * @param userId - User ID to delete
-   * @param type - User type ('app' or 'dashboard')
-   * @returns Deletion confirmation
+   * @param id - Conversation ID
+   * @returns Promise resolving to { data, error } tuple with conversation detail
    *
    * @example
    * ```typescript
-   * await admin.deleteUser('user-uuid');
-   * console.log('User deleted');
+   * const { data, error } = await ai.getConversation('conv-uuid-123')
+   * if (data) {
+   *   console.log(`Title: ${data.title}`)
+   *   console.log(`Messages: ${data.messages.length}`)
+   * }
    * ```
    */
-  async deleteUser(userId, type = "app") {
-    return wrapAsync(async () => {
-      const url = `/api/v1/admin/users/${userId}?type=${type}`;
-      return await this.fetch.delete(url);
-    });
+  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 };
+    }
   }
   /**
-   * Update user role
-   *
-   * Changes a user's role
+   * Delete a conversation
    *
-   * @param userId - User ID
-   * @param role - New role
-   * @param type - User type ('app' or 'dashboard')
-   * @returns Updated user
+   * @param id - Conversation ID
+   * @returns Promise resolving to { error } (null on success)
    *
    * @example
    * ```typescript
-   * const user = await admin.updateUserRole('user-uuid', 'admin');
-   * console.log('User role updated:', user.role);
+   * const { error } = await ai.deleteConversation('conv-uuid-123')
+   * if (!error) {
+   *   console.log('Conversation deleted')
+   * }
    * ```
    */
-  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 deleteConversation(id) {
+    try {
+      await this.fetch.delete(`/api/v1/ai/conversations/${id}`);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
   }
   /**
-   * Reset user password
+   * Update a conversation (currently supports title update only)
    *
-   * 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
+   * @param id - Conversation ID
+   * @param updates - Fields to update
+   * @returns Promise resolving to { data, error } tuple with updated conversation
    *
    * @example
    * ```typescript
-   * const response = await admin.resetUserPassword('user-uuid');
-   * console.log(response.message);
+   * const { data, error } = await ai.updateConversation('conv-uuid-123', {
+   *   title: 'My custom conversation title'
+   * })
    * ```
    */
-  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 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 };
+    }
   }
 };
 
@@ -6140,6 +7419,7 @@ var QueryBuilder = class {
     this.filters = [];
     this.orFilters = [];
     this.andFilters = [];
+    this.betweenFilters = [];
     this.orderBys = [];
     this.singleRow = false;
     this.maybeSingleRow = false;
@@ -6359,8 +7639,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 +7673,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)
@@ -6989,6 +8308,19 @@ var QueryBuilder = class {
     for (const andFilter of this.andFilters) {
       params.append("and", `(${andFilter})`);
     }
+    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})`
+        );
+      } else {
+        params.append(bf.column, `gte.${minFormatted}`);
+        params.append(bf.column, `lte.${maxFormatted}`);
+      }
+    }
     if (this.groupByColumns && this.groupByColumns.length > 0) {
       params.append("group_by", this.groupByColumns.join(","));
     }
@@ -7028,6 +8360,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)
@@ -7112,6 +8472,9 @@ 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.setupAuthSync();
   }
   /**
@@ -7172,38 +8535,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
@@ -7331,15 +8662,176 @@ 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.FluxbaseAI = FluxbaseAI;
+exports.FluxbaseAIChat = FluxbaseAIChat;
 exports.FluxbaseAdmin = FluxbaseAdmin;
+exports.FluxbaseAdminAI = FluxbaseAdminAI;
 exports.FluxbaseAdminFunctions = FluxbaseAdminFunctions;
 exports.FluxbaseAdminJobs = FluxbaseAdminJobs;
 exports.FluxbaseAdminMigrations = FluxbaseAdminMigrations;
+exports.FluxbaseAdminRPC = FluxbaseAdminRPC;
 exports.FluxbaseAuth = FluxbaseAuth;
 exports.FluxbaseClient = FluxbaseClient;
 exports.FluxbaseFetch = FluxbaseFetch;
@@ -7347,6 +8839,7 @@ exports.FluxbaseFunctions = FluxbaseFunctions;
 exports.FluxbaseJobs = FluxbaseJobs;
 exports.FluxbaseManagement = FluxbaseManagement;
 exports.FluxbaseOAuth = FluxbaseOAuth;
+exports.FluxbaseRPC = FluxbaseRPC;
 exports.FluxbaseRealtime = FluxbaseRealtime;
 exports.FluxbaseSettings = FluxbaseSettings;
 exports.FluxbaseStorage = FluxbaseStorage;
@@ -7360,6 +8853,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