@ragable/sdk 0.0.3 → 0.4.0

package/dist/index.mjs

@@ -223,6 +223,74 @@ function toArrayBuffer(value) {
   return copy.buffer;
 }
 
+// src/sse.ts
+async function parseMaybeJsonBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+  try {
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+function parseSseDataLine(line) {
+  const dataPrefix = "data: ";
+  if (!line.startsWith(dataPrefix)) {
+    return null;
+  }
+  const json = line.slice(dataPrefix.length).trim();
+  if (json.length === 0 || json === "[DONE]") {
+    return null;
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+async function* readSseStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      let boundary = buffer.indexOf("\n\n");
+      while (boundary !== -1) {
+        const block = buffer.slice(0, boundary);
+        buffer = buffer.slice(boundary + 2);
+        for (const line of block.split("\n")) {
+          const evt = parseSseDataLine(line);
+          if (evt) {
+            yield evt;
+          }
+        }
+        boundary = buffer.indexOf("\n\n");
+      }
+    }
+    if (buffer.trim().length > 0) {
+      for (const line of buffer.split("\n")) {
+        const evt = parseSseDataLine(line);
+        if (evt) {
+          yield evt;
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
 // src/agents.ts
 var AgentsClient = class {
   constructor(client) {
@@ -266,72 +334,655 @@ var AgentsClient = class {
     if (!body) {
       return;
     }
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        buffer += decoder.decode(value, { stream: true });
-        let boundary = buffer.indexOf("\n\n");
-        while (boundary !== -1) {
-          const block = buffer.slice(0, boundary);
-          buffer = buffer.slice(boundary + 2);
-          for (const line of block.split("\n")) {
-            const evt = parseSseDataLine(line);
-            if (evt) {
-              yield evt;
-            }
-          }
-          boundary = buffer.indexOf("\n\n");
-        }
+    yield* readSseStream(body);
+  }
+};
+
+// src/browser-postgrest.ts
+function assertIdent(name, ctx) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new RagableError(
+      `Invalid ${ctx} identifier "${name}" (use letters, numbers, underscore)`,
+      400,
+      null
+    );
+  }
+}
+function quoteIdent(name) {
+  assertIdent(name, "column");
+  return `"${name}"`;
+}
+var OP_SQL = {
+  eq: "=",
+  neq: "<>",
+  gt: ">",
+  gte: ">=",
+  lt: "<",
+  lte: "<=",
+  like: "LIKE",
+  ilike: "ILIKE"
+};
+async function asPostgrestResponse(fn) {
+  try {
+    const data = await fn();
+    return { data, error: null };
+  } catch (e) {
+    const err = e instanceof RagableError ? e : new RagableError(e.message, 500, null);
+    return { data: null, error: err };
+  }
+}
+function buildWhere(filters, params) {
+  if (filters.length === 0) return { clause: "", nextIdx: 1 };
+  const parts = [];
+  let i = params.length;
+  for (const f of filters) {
+    assertIdent(f.column, "filter");
+    i += 1;
+    parts.push(`${quoteIdent(f.column)} ${OP_SQL[f.op]} $${i}`);
+    params.push(f.value);
+  }
+  return { clause: ` WHERE ${parts.join(" AND ")}`, nextIdx: i };
+}
+var PostgrestSelectBuilder = class {
+  constructor(run, databaseInstanceId, table, columns) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.columns = columns;
+    __publicField(this, "filters", []);
+    __publicField(this, "_limit");
+    __publicField(this, "_order");
+    assertIdent(table, "table");
+  }
+  eq(column, value) {
+    this.filters.push({ op: "eq", column, value });
+    return this;
+  }
+  neq(column, value) {
+    this.filters.push({ op: "neq", column, value });
+    return this;
+  }
+  gt(column, value) {
+    this.filters.push({ op: "gt", column, value });
+    return this;
+  }
+  gte(column, value) {
+    this.filters.push({ op: "gte", column, value });
+    return this;
+  }
+  lt(column, value) {
+    this.filters.push({ op: "lt", column, value });
+    return this;
+  }
+  lte(column, value) {
+    this.filters.push({ op: "lte", column, value });
+    return this;
+  }
+  like(column, value) {
+    this.filters.push({ op: "like", column, value });
+    return this;
+  }
+  ilike(column, value) {
+    this.filters.push({ op: "ilike", column, value });
+    return this;
+  }
+  limit(n) {
+    this._limit = n;
+    return this;
+  }
+  order(column, options) {
+    this._order = { column, ascending: options?.ascending !== false };
+    return this;
+  }
+  /** @param includeUserLimit when false, omit `.limit()` (for `.single()` / `.maybeSingle()`). */
+  buildSelectCore(params, includeUserLimit) {
+    const tbl = quoteIdent(this.table);
+    const { clause } = buildWhere(this.filters, params);
+    let sql = `SELECT ${this.columns} FROM ${tbl}${clause}`;
+    if (this._order) {
+      sql += ` ORDER BY ${quoteIdent(this._order.column)} ${this._order.ascending ? "ASC" : "DESC"}`;
+    }
+    if (includeUserLimit && this._limit != null) {
+      sql += ` LIMIT ${Math.max(0, Math.floor(this._limit))}`;
+    }
+    return sql;
+  }
+  then(onfulfilled, onrejected) {
+    return this.executeMany().then(onfulfilled, onrejected);
+  }
+  async executeMany() {
+    return asPostgrestResponse(async () => {
+      const params = [];
+      const sql = this.buildSelectCore(params, true);
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: true
+      });
+      return res.rows;
+    });
+  }
+  async single() {
+    return asPostgrestResponse(async () => {
+      const params = [];
+      const base = this.buildSelectCore(params, false);
+      const sql = `${base} LIMIT 2`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: true
+      });
+      if (res.rows.length === 0) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
       }
-      if (buffer.trim().length > 0) {
-        for (const line of buffer.split("\n")) {
-          const evt = parseSseDataLine(line);
-          if (evt) {
-            yield evt;
-          }
+      if (res.rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return res.rows[0];
+    });
+  }
+  async maybeSingle() {
+    return asPostgrestResponse(async () => {
+      const params = [];
+      const base = this.buildSelectCore(params, false);
+      const sql = `${base} LIMIT 2`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: true
+      });
+      if (res.rows.length > 1) {
+        throw new RagableError("JSON object requested, multiple (or no) rows returned", 406, {
+          code: "PGRST116"
+        });
+      }
+      return res.rows[0] ?? null;
+    });
+  }
+};
+var PostgrestInsertBuilder = class {
+  constructor(run, databaseInstanceId, table, rows) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.rows = rows;
+    __publicField(this, "returning", "*");
+    assertIdent(table, "table");
+  }
+  select(columns = "*") {
+    this.returning = columns;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  async execute() {
+    return asPostgrestResponse(async () => {
+      if (this.rows.length === 0) return [];
+      const keys = Object.keys(this.rows[0]);
+      for (const k of keys) assertIdent(k, "column");
+      const tbl = quoteIdent(this.table);
+      const params = [];
+      const valueGroups = [];
+      for (const row of this.rows) {
+        const placeholders = [];
+        for (const k of keys) {
+          params.push(row[k]);
+          placeholders.push(`$${params.length}`);
         }
+        valueGroups.push(`(${placeholders.join(", ")})`);
       }
-    } finally {
-      reader.releaseLock();
-    }
+      const cols = keys.map(quoteIdent).join(", ");
+      const sql = `INSERT INTO ${tbl} (${cols}) VALUES ${valueGroups.join(", ")} RETURNING ${this.returning}`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return res.rows;
+    });
   }
 };
-async function parseMaybeJsonBody(response) {
-  const contentType = response.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    try {
-      return await response.json();
-    } catch {
-      return null;
-    }
+var PostgrestUpdateBuilder = class {
+  constructor(run, databaseInstanceId, table, patch) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    this.patch = patch;
+    __publicField(this, "filters", []);
+    __publicField(this, "returning", "*");
+    assertIdent(table, "table");
   }
-  try {
-    return await response.text();
-  } catch {
-    return null;
+  eq(column, value) {
+    this.filters.push({ op: "eq", column, value });
+    return this;
+  }
+  select(columns = "*") {
+    this.returning = columns;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  async execute() {
+    return asPostgrestResponse(async () => {
+      const keys = Object.keys(this.patch);
+      if (keys.length === 0) {
+        throw new RagableError("Empty update payload", 400, null);
+      }
+      for (const k of keys) assertIdent(k, "column");
+      if (this.filters.length === 0) {
+        throw new RagableError(
+          "UPDATE requires a filter (e.g. .eq('id', value)) \u2014 refusing unscoped update",
+          400,
+          null
+        );
+      }
+      const params = [];
+      const sets = [];
+      for (const k of keys) {
+        params.push(this.patch[k]);
+        sets.push(`${quoteIdent(k)} = $${params.length}`);
+      }
+      const { clause } = buildWhere(this.filters, params);
+      const tbl = quoteIdent(this.table);
+      const sql = `UPDATE ${tbl} SET ${sets.join(", ")}${clause} RETURNING ${this.returning}`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return res.rows;
+    });
+  }
+};
+var PostgrestDeleteBuilder = class {
+  constructor(run, databaseInstanceId, table) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+    __publicField(this, "filters", []);
+    __publicField(this, "returning", "*");
+    assertIdent(table, "table");
+  }
+  eq(column, value) {
+    this.filters.push({ op: "eq", column, value });
+    return this;
+  }
+  select(columns = "*") {
+    this.returning = columns;
+    return this;
+  }
+  then(onfulfilled, onrejected) {
+    return this.execute().then(onfulfilled, onrejected);
+  }
+  async execute() {
+    return asPostgrestResponse(async () => {
+      if (this.filters.length === 0) {
+        throw new RagableError(
+          "DELETE requires a filter (e.g. .eq('id', value)) \u2014 refusing unscoped delete",
+          400,
+          null
+        );
+      }
+      const params = [];
+      const { clause } = buildWhere(this.filters, params);
+      const tbl = quoteIdent(this.table);
+      const sql = `DELETE FROM ${tbl}${clause} RETURNING ${this.returning}`;
+      const res = await this.run({
+        databaseInstanceId: this.databaseInstanceId,
+        sql,
+        params,
+        readOnly: false
+      });
+      return res.rows;
+    });
+  }
+};
+var PostgrestTableApi = class {
+  constructor(run, databaseInstanceId, table) {
+    this.run = run;
+    this.databaseInstanceId = databaseInstanceId;
+    this.table = table;
+  }
+  select(columns = "*") {
+    return new PostgrestSelectBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      columns
+    );
+  }
+  insert(values) {
+    const rows = Array.isArray(values) ? values : [values];
+    return new PostgrestInsertBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      rows
+    );
+  }
+  update(patch) {
+    return new PostgrestUpdateBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table,
+      patch
+    );
+  }
+  delete() {
+    return new PostgrestDeleteBuilder(
+      this.run,
+      this.databaseInstanceId,
+      this.table
+    );
   }
+};
+
+// src/browser.ts
+function normalizeBrowserApiBase(baseUrl) {
+  return (baseUrl ?? "http://localhost:8080/api").replace(/\/+$/, "");
 }
-function parseSseDataLine(line) {
-  const dataPrefix = "data: ";
-  if (!line.startsWith(dataPrefix)) {
-    return null;
+function requireAuthGroupId(options) {
+  const id = options.authGroupId?.trim();
+  if (!id) {
+    throw new Error(
+      "authGroupId is required for auth and database methods on the browser client"
+    );
   }
-  const json = line.slice(dataPrefix.length).trim();
-  if (json.length === 0 || json === "[DONE]") {
-    return null;
+  return id;
+}
+async function requireAccessToken(options) {
+  const getter = options.getAccessToken;
+  if (!getter) {
+    throw new Error(
+      "getAccessToken is required for this call (return the end-user access JWT)"
+    );
   }
-  try {
-    return JSON.parse(json);
-  } catch {
-    return null;
+  const token = await getter();
+  if (!token?.trim()) {
+    throw new Error("getAccessToken returned no token");
+  }
+  return token.trim();
+}
+async function parseJsonOrThrow(response) {
+  const payload = await parseMaybeJsonBody(response);
+  if (!response.ok) {
+    const message = extractErrorMessage(payload, response.statusText);
+    throw new RagableError(message, response.status, payload);
+  }
+  return payload;
+}
+function parseExpiresInSeconds(expiresIn) {
+  const s = expiresIn.trim().toLowerCase();
+  const m = /^(\d+)([smhd])?$/.exec(s);
+  if (m) {
+    const n = Number(m[1]);
+    const u = m[2] ?? "s";
+    const mult = u === "s" ? 1 : u === "m" ? 60 : u === "h" ? 3600 : u === "d" ? 86400 : 1;
+    return n * mult;
+  }
+  const asNum = Number(s);
+  return Number.isFinite(asNum) ? asNum : 0;
+}
+function toSupabaseSession(s) {
+  return {
+    access_token: s.accessToken,
+    refresh_token: s.refreshToken,
+    expires_in: parseExpiresInSeconds(s.expiresIn),
+    token_type: "bearer",
+    user: s.user
+  };
+}
+var RagableBrowserAuthClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get fetchImpl() {
+    return this.options.fetch ?? fetch;
+  }
+  toUrl(path) {
+    return `${normalizeBrowserApiBase(this.options.baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  baseHeaders(json) {
+    const h = new Headers(this.options.headers);
+    if (json) {
+      h.set("Content-Type", "application/json");
+    }
+    return h;
+  }
+  authPrefix() {
+    const gid = requireAuthGroupId(this.options);
+    return `/auth-groups/${gid}/auth`;
+  }
+  /** Supabase: `signUp` → `{ data: { user, session }, error }` */
+  async signUp(credentials) {
+    return asPostgrestResponse(async () => {
+      const name = typeof credentials.options?.data?.name === "string" ? credentials.options.data.name : void 0;
+      const session = await this.register({
+        email: credentials.email,
+        password: credentials.password,
+        name
+      });
+      return { user: session.user, session: toSupabaseSession(session) };
+    });
+  }
+  /** Supabase: `signInWithPassword` */
+  async signInWithPassword(credentials) {
+    return asPostgrestResponse(async () => {
+      const session = await this.login(credentials);
+      return { user: session.user, session: toSupabaseSession(session) };
+    });
+  }
+  /** Supabase: `refreshSession` */
+  async refreshSession(refreshToken) {
+    return asPostgrestResponse(async () => {
+      const tokens = await this.refresh({ refreshToken });
+      const me = await this.getUserFromToken(tokens.accessToken);
+      const session = {
+        access_token: tokens.accessToken,
+        refresh_token: tokens.refreshToken,
+        expires_in: parseExpiresInSeconds(tokens.expiresIn),
+        token_type: "bearer",
+        user: me.user
+      };
+      return { session, user: me.user };
+    });
+  }
+  /** Supabase: `getUser()` — needs `getAccessToken` on the client */
+  async getUser() {
+    return asPostgrestResponse(() => this.getMe());
+  }
+  /** Supabase: `updateUser` */
+  async updateUser(attributes) {
+    return asPostgrestResponse(
+      () => this.updateMe({
+        password: attributes.password,
+        name: attributes.data?.name
+      })
+    );
+  }
+  /**
+   * Supabase/Firebase: no server call — clear tokens in your app.
+   * Returns `{ error: null }` for API compatibility.
+   */
+  async signOut(_options) {
+    return { error: null };
+  }
+  async getUserFromToken(accessToken) {
+    const headers = this.baseHeaders(false);
+    headers.set("Authorization", `Bearer ${accessToken}`);
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/me`, {
+      method: "GET",
+      headers
+    });
+    return parseJsonOrThrow(response);
+  }
+  async register(body) {
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/register`, {
+      method: "POST",
+      headers: this.baseHeaders(true),
+      body: JSON.stringify(body)
+    });
+    return parseJsonOrThrow(response);
   }
+  async login(body) {
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/login`, {
+      method: "POST",
+      headers: this.baseHeaders(true),
+      body: JSON.stringify(body)
+    });
+    return parseJsonOrThrow(response);
+  }
+  async refresh(body) {
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/refresh`, {
+      method: "POST",
+      headers: this.baseHeaders(true),
+      body: JSON.stringify(body)
+    });
+    return parseJsonOrThrow(response);
+  }
+  async getMe() {
+    const token = await requireAccessToken(this.options);
+    const headers = this.baseHeaders(false);
+    headers.set("Authorization", `Bearer ${token}`);
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/me`, {
+      method: "GET",
+      headers
+    });
+    return parseJsonOrThrow(response);
+  }
+  async updateMe(body) {
+    const token = await requireAccessToken(this.options);
+    const headers = this.baseHeaders(true);
+    headers.set("Authorization", `Bearer ${token}`);
+    const response = await this.fetchImpl(`${this.toUrl(this.authPrefix())}/me`, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(body)
+    });
+    return parseJsonOrThrow(response);
+  }
+};
+var RagableBrowserDatabaseClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get fetchImpl() {
+    return this.options.fetch ?? fetch;
+  }
+  toUrl(path) {
+    return `${normalizeBrowserApiBase(this.options.baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  async query(params) {
+    const gid = requireAuthGroupId(this.options);
+    const token = await requireAccessToken(this.options);
+    const headers = this.baseHeaders();
+    headers.set("Authorization", `Bearer ${token}`);
+    headers.set("Content-Type", "application/json");
+    const response = await this.fetchImpl(
+      this.toUrl(`/auth-groups/${gid}/data/query`),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          databaseInstanceId: params.databaseInstanceId,
+          sql: params.sql,
+          ...params.params !== void 0 ? { params: params.params } : {},
+          ...params.readOnly === false ? { readOnly: false } : {},
+          ...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
+          ...params.rowLimit !== void 0 ? { rowLimit: params.rowLimit } : {}
+        })
+      }
+    );
+    return parseJsonOrThrow(response);
+  }
+  baseHeaders() {
+    return new Headers(this.options.headers);
+  }
+};
+var RagableBrowserAgentsClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  get fetchImpl() {
+    return this.options.fetch ?? fetch;
+  }
+  toUrl(path) {
+    return `${normalizeBrowserApiBase(this.options.baseUrl)}${path.startsWith("/") ? path : `/${path}`}`;
+  }
+  /**
+   * Stream agent execution as SSE (`POST /public/organizations/:orgId/agents/:agentId/chat/stream`).
+   */
+  async *chatStream(agentId, params) {
+    const orgId = this.options.organizationId;
+    const body = {
+      message: params.message,
+      ...params.history !== void 0 ? { history: params.history } : {},
+      ...params.triggerSubtype !== void 0 ? { triggerSubtype: params.triggerSubtype } : {},
+      ...params.triggerNodeId !== void 0 ? { triggerNodeId: params.triggerNodeId } : {}
+    };
+    const headers = new Headers(this.options.headers);
+    headers.set("Content-Type", "application/json");
+    const response = await this.fetchImpl(
+      this.toUrl(`/public/organizations/${orgId}/agents/${agentId}/chat/stream`),
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      }
+    );
+    if (!response.ok) {
+      const payload = await parseMaybeJsonBody(response);
+      const message = extractErrorMessage(payload, response.statusText);
+      throw new RagableError(message, response.status, payload);
+    }
+    const streamBody = response.body;
+    if (!streamBody) {
+      return;
+    }
+    yield* readSseStream(streamBody);
+  }
+};
+var RagableBrowser = class {
+  constructor(options) {
+    __publicField(this, "agents");
+    __publicField(this, "auth");
+    __publicField(this, "database");
+    __publicField(this, "options");
+    this.options = options;
+    this.agents = new RagableBrowserAgentsClient(options);
+    this.auth = new RagableBrowserAuthClient(options);
+    this.database = new RagableBrowserDatabaseClient(options);
+  }
+  /**
+   * Supabase-style table API: `.from('items').select().eq('id', 1).single()`.
+   * Pass `databaseInstanceId` here or set `databaseInstanceId` on the client options.
+   */
+  from(table, databaseInstanceId) {
+    const id = databaseInstanceId?.trim() || this.options.databaseInstanceId?.trim();
+    if (!id) {
+      throw new Error(
+        "RagableBrowser.from() requires databaseInstanceId in client options or as the second argument"
+      );
+    }
+    const run = (p) => this.database.query(p);
+    return new PostgrestTableApi(run, id, table);
+  }
+};
+function createBrowserClient(options) {
+  return new RagableBrowser(options);
 }
+var createRagableBrowserClient = createBrowserClient;
 
 // src/rag.ts
 function formatRetrievalContext(results, options = {}) {
@@ -389,18 +1040,63 @@ var Ragable = class {
     };
   }
 };
-function createClient(options) {
+function isServerClientOptions(o) {
+  return typeof o === "object" && o !== null && "apiKey" in o && typeof o.apiKey === "string" && o.apiKey.length > 0;
+}
+function createClient(urlOrOptions, browserOptions) {
+  if (typeof urlOrOptions === "string") {
+    if (!browserOptions) {
+      throw new Error(
+        "createClient(url, options) requires options with at least organizationId"
+      );
+    }
+    const raw = urlOrOptions.trim().replace(/\/+$/, "");
+    const baseUrl = raw.endsWith("/api") ? raw : `${raw}/api`;
+    return createBrowserClient({
+      ...browserOptions,
+      baseUrl: normalizeBrowserApiBase(baseUrl)
+    });
+  }
+  if (isServerClientOptions(urlOrOptions)) {
+    return new Ragable(urlOrOptions);
+  }
+  if (typeof urlOrOptions === "object" && urlOrOptions !== null && "organizationId" in urlOrOptions && typeof urlOrOptions.organizationId === "string") {
+    return createBrowserClient(
+      urlOrOptions
+    );
+  }
+  throw new Error(
+    "createClient(options) requires apiKey (server) or organizationId (browser)"
+  );
+}
+function createRagableServerClient(options) {
   return new Ragable(options);
 }
 export {
   AgentsClient,
+  PostgrestDeleteBuilder,
+  PostgrestInsertBuilder,
+  PostgrestSelectBuilder,
+  PostgrestTableApi,
+  PostgrestUpdateBuilder,
   Ragable,
+  RagableBrowser,
+  RagableBrowserAgentsClient,
+  RagableBrowserAuthClient,
+  RagableBrowserDatabaseClient,
   RagableError,
   RagableRequestClient,
   ShiftClient,
+  asPostgrestResponse,
+  createBrowserClient,
   createClient,
   createRagPipeline,
+  createRagableBrowserClient,
+  createRagableServerClient,
   extractErrorMessage,
-  formatRetrievalContext
+  formatRetrievalContext,
+  normalizeBrowserApiBase,
+  parseSseDataLine,
+  readSseStream
 };
 //# sourceMappingURL=index.mjs.map