@ragable/sdk 0.8.0 → 0.8.2

package/dist/index.d.ts

@@ -708,7 +708,7 @@ declare class AuthBroadcastChannel {
     close(): void;
 }
 
-type AuthChangeEvent = "INITIAL_SESSION" | "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "USER_UPDATED";
+type AuthChangeEvent = "INITIAL_SESSION" | "SIGNED_IN" | "SIGNED_OUT" | "TOKEN_REFRESHED" | "TOKEN_REFRESH_FAILED" | "USER_UPDATED";
 type AuthUserMetadata = Record<string, unknown>;
 interface DefaultAuthUser<Metadata extends AuthUserMetadata = AuthUserMetadata> {
     id: string;
@@ -783,10 +783,26 @@ declare class RagableAuth<U extends object = DefaultAuthUser> {
     private listeners;
     private broadcast;
     private visibilityHandler;
-    private initialized;
+    /** Memoizes the one-shot restore so concurrent callers (constructor eager init,
+     *  every `onAuthStateChange` subscriber, `getSession`) share a single result.
+     *  Non-null also means "restore has started", replacing the old boolean flag. */
+    private initializePromise;
+    /** Bumped on every explicit session change (sign-in/out, refresh). The async
+     *  restore captures this and refuses to overwrite a newer session op that
+     *  landed while it was reading storage (e.g. a sign-out during page load). */
+    private sessionEpoch;
     constructor(config: RagableAuthConfig);
     private log;
+    /**
+     * Restore a persisted session (once). Memoized: every caller awaits the same
+     * promise, so the eager constructor init, `getSession`, and each
+     * `onAuthStateChange` subscriber's INITIAL_SESSION replay never race or
+     * double-restore. Does NOT emit `INITIAL_SESSION` globally — that event is
+     * delivered per-subscriber by `onAuthStateChange` (Supabase-parity), so a
+     * listener attached after restore still sees the existing session.
+     */
     initialize(): Promise<AuthSession<U> | null>;
+    private _initialize;
     signUp(credentials: AuthSignUpCredentials<MetadataForUser<U>>): Promise<PostgrestResult<{
         user: U;
         session: AuthSession<U>;
@@ -835,7 +851,14 @@ declare class RagableAuth<U extends object = DefaultAuthUser> {
         };
     };
     getAccessToken(): string | null;
-    getValidAccessToken(): Promise<string | null>;
+    /**
+     * Returns an access token guaranteed fresh for at least `refreshSkewSeconds`,
+     * refreshing (single-flight) if needed. Pass `force: true` to bypass the skew
+     * check and refresh now — used by the transport's 401 handler so a token the
+     * server rejected (key rotation, clock skew, early revocation) self-heals on
+     * retry instead of failing the call.
+     */
+    getValidAccessToken(force?: boolean): Promise<string | null>;
     getCurrentSession(): AuthSession<U> | null;
     register(body: {
         email: string;
@@ -891,7 +914,17 @@ declare class RagableAuth<U extends object = DefaultAuthUser> {
     private emit;
     private scheduleRefresh;
     private clearRefreshTimer;
+    /**
+     * Refresh the session, deduplicating concurrent callers onto one in-flight
+     * request. Side effects (persisting the new session, or clearing it and
+     * emitting SIGNED_OUT / TOKEN_REFRESH_FAILED) run exactly once inside the
+     * shared promise, so two callers can't double-emit. Resolves to the new
+     * session, or `null` when the refresh failed.
+     */
     singleFlightRefresh(refreshToken: string): Promise<AuthSession<U> | null>;
+    /** Clear the session locally and emit SIGNED_OUT after a definitively-rejected
+     *  refresh, so onAuthStateChange-driven UI redirects to login. */
+    private handleTerminalRefreshFailure;
     private _doRefresh;
     private setupVisibilityListener;
 }
@@ -1246,6 +1279,106 @@ declare function streamObjectFromContext<T = unknown>(ctx: InferenceRequestConte
  */
 declare function wrapStreamTextAsObject<T = unknown>(inner: StreamTextResult): StreamObjectResult<T>;
 
+/**
+ * Server-side client — the authenticated SDK for code that runs on a trusted
+ * server (a Ragable backend **function**, an Engine, or your own Node service).
+ *
+ * Unlike the browser client there is **no sign-in / session machinery** here:
+ * a server is not a logged-in user. Instead you provide credentials up front and
+ * the client speaks to the same Ragable data plane the browser uses, so the
+ * semantics (collection security, `{ data, error }` shapes, PostgREST) are
+ * identical — this reuses the exact same fetch-based sub-clients, never a
+ * reimplementation.
+ *
+ * Two privilege levels:
+ *  - **caller** (default): acts as the end user who invoked you — uses their
+ *    forwarded access token, falling back to the public anon key for anonymous
+ *    callers. Collection security applies, exactly as in the browser.
+ *  - **admin**: authenticates with the auth group's **data-admin key**, which
+ *    bypasses collection security (owner/group/claim grants do not apply) and
+ *    can write protected collections. Reach for it deliberately.
+ *
+ * ```ts
+ * // inside /functions/<name>.ts — `context.ragable` is a pre-built server client
+ * export default async function createTask(input, context) {
+ *   // as the caller (respects collection security):
+ *   const { data, error } = await context.ragable.db.collections.tasks.insert(input);
+ *   // privileged work (bypasses collection security):
+ *   await context.ragable.asAdmin().db.collections.audit_log.insert({ action: "create" });
+ *   return data;
+ * }
+ * ```
+ */
+
+/** Which credential a server client authenticates with. */
+type ServerPrivilege = "caller" | "admin";
+/**
+ * Inputs to {@link createServerClient}. The IDs and keys are normally supplied by
+ * the runtime (a function's injected `context.ragable`); construct one by hand
+ * only for a standalone server.
+ */
+interface RagableServerClientConfig {
+    organizationId: string;
+    websiteId?: string;
+    authGroupId?: string;
+    databaseInstanceId?: string;
+    storageBucketId?: string;
+    mailAccountId?: string;
+    /**
+     * The auth group's **data-admin key**. Required for `admin` privilege; omit it
+     * and `asAdmin()` throws. Server-only — never expose this to the browser.
+     */
+    adminKey?: string;
+    /**
+     * The invoking end user's access token (a real auth-group JWT), forwarded by
+     * the runtime. `null`/omitted for anonymous callers. Used by `caller`
+     * privilege; the public anon key is the fallback when this is absent.
+     */
+    callerToken?: string | null;
+    /** Public anon key — the `caller` fallback when no end user is signed in. */
+    publicAnonKey?: string;
+    /** Default privilege for the returned client. Defaults to `"caller"`. */
+    defaultPrivilege?: ServerPrivilege;
+    fetch?: typeof fetch;
+    headers?: HeadersInit;
+}
+/**
+ * A trusted, server-side Ragable client. Surface mirrors the browser client
+ * (`db`, `storage`, `mail`, `functions`, `ai`, `agents`) minus `auth` — a server
+ * authenticates with keys, not a session. Switch privilege with {@link asAdmin}
+ * / {@link asCaller}.
+ */
+declare class RagableServerClient<Database extends RagableDatabase = DefaultRagableDatabase, Functions extends RagableFunctions = DefaultRagableFunctions> {
+    private readonly config;
+    readonly database: RagableBrowserDatabaseClient<Database>;
+    readonly db: RagableBrowserDatabaseClient<Database>;
+    readonly storage: RagableBrowserStorageClient;
+    readonly mail: RagableBrowserMailClient;
+    readonly functions: FunctionInvoker<Functions>;
+    readonly ai: RagableBrowserAiClient;
+    readonly agents: RagableBrowserAgentsClient;
+    /** Which credential this client is using. */
+    readonly privilege: ServerPrivilege;
+    constructor(config: RagableServerClientConfig, privilege: ServerPrivilege);
+    /**
+     * A client authenticated with the **data-admin key** — bypasses collection
+     * security (owner/group/claim grants do not apply) and can write protected
+     * collections. Throws `SDK_ADMIN_KEY_REQUIRED` when no admin key is configured.
+     */
+    asAdmin(): RagableServerClient<Database, Functions>;
+    /**
+     * A client scoped to the invoking end user's identity (respects collection
+     * security). This is already the default; use it to drop back from `asAdmin()`.
+     */
+    asCaller(): RagableServerClient<Database, Functions>;
+}
+/**
+ * Create a server-side Ragable client. Defaults to **caller** privilege (acts as
+ * the invoking end user, respecting collection security); call `.asAdmin()` for
+ * privileged, security-bypassing access.
+ */
+declare function createServerClient<Database extends RagableDatabase = DefaultRagableDatabase, Functions extends RagableFunctions = DefaultRagableFunctions>(config: RagableServerClientConfig): RagableServerClient<Database, Functions>;
+
 /**
  * Backend "edge functions".
  *
@@ -1274,6 +1407,7 @@ declare function wrapStreamTextAsObject<T = unknown>(inner: StreamTextResult): S
  * The handler's second argument (`context`) is injected by the server; callers
  * pass only `input`.
  */
+
 /**
  * Server-injected second argument to every function handler. Never constructed
  * on the client — the values come from the backend at invocation time.
@@ -1298,6 +1432,16 @@ interface RagableFunctionContext {
     auth: {
         token: string | null;
     };
+    /**
+     * A pre-authenticated {@link RagableServerClient} for talking back to your
+     * Ragable Cloud (db / storage / mail / functions / ai / agents) — already
+     * wired to this project, no setup or keys to manage.
+     *
+     * Defaults to the **caller's** identity, so collection security applies just
+     * like in the browser. Call `context.ragable.asAdmin()` for privileged work
+     * that must bypass collection security (e.g. owner-only writes, audit logs).
+     */
+    ragable: RagableServerClient;
 }
 /**
  * The shape a `/functions/<name>.ts` default export must satisfy. Type the
@@ -1340,13 +1484,23 @@ type FunctionInvoker<F extends RagableFunctions = DefaultRagableFunctions> = {
 
 /** Canonical browser/server API base (`…/api`, no trailing slash). */
 declare function normalizeBrowserApiBase(): string;
-type BrowserDataAuthMode = "user" | "publicAnon" | "admin";
+type BrowserDataAuthMode = "user" | "publicAnon" | "admin" | "auto";
 /**
- * Resolves how database requests are authorized. If `dataAuth` is omitted and a
- * static browser data key is configured (`dataStaticKey` / `getDataStaticKey`),
- * defaults to **`publicAnon`** so public apps can use shared collections without
- * sign-in. Use explicit **`dataAuth: "user"`** when you need JWT sessions; use
- * **`"admin"`** when the static key is a data-admin key.
+ * Resolves how database / storage requests are authorized.
+ *
+ * Default (when `dataAuth` is omitted):
+ * - **`auto`** when BOTH a static data key AND user auth (an `authGroupId` or a
+ *   `getAccessToken` callback) are configured — the generated-site case. This is
+ *   the Supabase model: send the signed-in user's JWT when a session exists, and
+ *   fall back to the public anon key for logged-out visitors. Without this, a
+ *   shipped anon key permanently shadows the user session, so owner/group/claim/
+ *   authenticated collection grants can never match a signed-in user.
+ * - **`publicAnon`** when only a static key is configured (no auth group) — a
+ *   purely public app.
+ * - **`user`** when neither — JWT-only.
+ *
+ * Set `dataAuth` explicitly to override: `"user"` (JWT required), `"publicAnon"`
+ * (anon key only, never upgrade), or `"admin"` (the static key is a data-admin key).
  */
 declare function effectiveDataAuth(options: RagableBrowserClientOptions): BrowserDataAuthMode;
 interface RagableBrowserClientOptions {
@@ -1461,6 +1615,12 @@ declare class RagableBrowserAuthClient<AuthUser extends object = DefaultAuthUser
     getSession(): Promise<PostgrestResult<{
         session: AuthSession<AuthUser> | null;
     }>>;
+    /**
+     * Returns a valid (auto-refreshed) access token for the current session, or
+     * `null` if signed out. The sanctioned way to obtain a token for a hand-rolled
+     * `fetch` to a custom endpoint — never read tokens out of storage yourself.
+     */
+    getValidAccessToken(): Promise<string | null>;
 }
 interface BrowserSqlQueryParams {
     databaseInstanceId?: string;
@@ -1556,6 +1716,15 @@ type CollectionRowWithMeta<Row extends Record<string, unknown> = Record<string,
 };
 declare function collectionRecordToRowWithMeta<Row extends Record<string, unknown>>(record: BrowserCollectionRecord<Row>): CollectionRowWithMeta<Row>;
 declare function collectionRecordsToRowWithMeta<Row extends Record<string, unknown>>(records: BrowserCollectionRecord<Row>[]): CollectionRowWithMeta<Row>[];
+/**
+ * Rows returned by a find: {@link CollectionRowWithMeta} when the params carry
+ * a literal `return: "flat"`, envelope {@link BrowserCollectionRecord}s
+ * otherwise. Keeps the default (envelope) call sites free of union-narrowing —
+ * `res.data[0].data` typechecks without a cast.
+ */
+type CollectionFindResult<Row extends Record<string, unknown>, Params> = Params extends {
+    return: "flat";
+} ? CollectionRowWithMeta<Row>[] : BrowserCollectionRecord<Row>[];
 type BrowserCollectionFindParams<Row extends Record<string, unknown> = Record<string, unknown>> = {
     where?: WhereInput<Row>;
     filters?: Array<{
@@ -1586,11 +1755,11 @@ declare class BrowserCollectionApi<Row extends Record<string, unknown> = Record<
      * Query collection rows. Prefer this over the deprecated `find` alias.
      * Use `return: "flat"` to get {@link CollectionRowWithMeta} without nested `.data`.
      */
-    findMany: (whereOrParams?: WhereInput<RowD<Row>> | BrowserCollectionFindParams<RowD<Row>>) => Promise<PostgrestResult<BrowserCollectionRecord<RowD<Row>>[] | CollectionRowWithMeta<RowD<Row>>[]>>;
+    findMany: <Params extends WhereInput<RowD<Row>> | BrowserCollectionFindParams<RowD<Row>>>(whereOrParams?: Params) => Promise<PostgrestResult<CollectionFindResult<RowD<Row>, Params>>>;
     /**
      * @deprecated Use {@link BrowserCollectionApi.findMany} — same behavior.
      */
-    find: (whereOrParams?: WhereInput<RowD<Row>> | BrowserCollectionFindParams<RowD<Row>>) => Promise<PostgrestResult<BrowserCollectionRecord<RowD<Row>>[] | CollectionRowWithMeta<RowD<Row>>[]>>;
+    find: <Params extends WhereInput<RowD<Row>> | BrowserCollectionFindParams<RowD<Row>>>(whereOrParams?: Params) => Promise<PostgrestResult<CollectionFindResult<RowD<Row>, Params>>>;
     /**
      * At most one row, `data` is the record or `null` if none match (not an error).
      */
@@ -1811,10 +1980,24 @@ declare class BrowserStorageBucketClient {
     private readonly options;
     private readonly fetchImpl;
     private readonly bucketId;
-    constructor(options: RagableBrowserClientOptions, fetchImpl: typeof fetch, bucketId: string);
+    private readonly ragableAuth;
+    constructor(options: RagableBrowserClientOptions, fetchImpl: typeof fetch, bucketId: string, ragableAuth?: RagableAuth | null);
     private get authGroupId();
     private base;
+    /**
+     * Same credential resolution as the database client (see resolveDatabaseAuthBearer):
+     * in the generated-site default (`auto`), a signed-in user's auto-refreshed JWT
+     * is used so storage calls carry the user's identity; logged-out visitors fall
+     * back to the anon key. Previously storage ignored the managed session entirely.
+     */
     private bearerToken;
+    /**
+     * The storage backend has historically returned HTTP 200 with an `{ error }`
+     * body on some failures; without this guard the SDK would resolve those as
+     * successful uploads/deletes. Treat any 2xx whose body carries a non-empty
+     * `error` as a failure.
+     */
+    private assertNoEmbeddedError;
     private req;
     list(params?: {
         prefix?: string;
@@ -1883,7 +2066,8 @@ declare class BrowserStorageBucketClient {
 declare class RagableBrowserStorageClient {
     private readonly options;
     private readonly fetchImpl;
-    constructor(options: RagableBrowserClientOptions, fetchImpl: typeof fetch);
+    private readonly ragableAuth;
+    constructor(options: RagableBrowserClientOptions, fetchImpl: typeof fetch, ragableAuth?: RagableAuth | null);
     from(bucketId: string): BrowserStorageBucketClient;
 }
 interface MailSendParams {
@@ -2156,6 +2340,13 @@ declare class RagableBrowser<Database extends RagableDatabase = DefaultRagableDa
     constructor(options: RagableBrowserClientOptions);
     /** Delegates to `database.from()`. Kept for back-compat — prefer `database.from()`. */
     from: <TableName extends RagableTableNames<Database>>(table: TableName, databaseInstanceId?: string) => PostgrestTableApi<Database, TableName>;
+    /**
+     * Resolves once the persisted session has been restored (and refreshed if it
+     * was expired). Await this before reading auth state at startup to avoid a
+     * logged-out flash, e.g. `const session = await client.ready()`. Resolves
+     * `null` when no auth group is configured or no session is stored.
+     */
+    ready(): Promise<AuthSession<AuthUser> | null>;
     destroy(): void;
 }
 declare function createBrowserClient<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser, Functions extends RagableFunctions = DefaultRagableFunctions>(options: RagableBrowserClientOptions): RagableBrowser<Database, AuthUser, Functions>;
@@ -2191,4 +2382,4 @@ declare function tryParsePartialJson(text: string): unknown | undefined;
 
 declare function createClient<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser, Functions extends RagableFunctions = DefaultRagableFunctions>(options: RagableBrowserClientOptions): RagableBrowser<Database, AuthUser, Functions>;
 
-export { type AgentChatMessage, type AgentChatParams, type AgentChatStreamDonePayload, type AgentChatStreamHandlers, type AgentChatStreamResult, type AgentChatStreamUiHandlers, type AgentChatUiAssistantMessage, type AgentChatUiSegment, type AgentChatUiStreamResult, type AgentConversation, type AgentConversationMessage, type AgentConversationSubscription, type AgentPublicChatParams, type AgentStreamAgentInfoEvent, type AgentStreamEvent, AuthBroadcastChannel, type AuthBroadcastMessage, type AuthChangeEvent, type AuthOptions, type AuthSession, type AuthSignUpCredentials, type AuthUpdateUserAttributes, type AuthUserMetadata, type BrowserAuthSession, type BrowserAuthTokens, BrowserCollectionApi, type BrowserCollectionDefinition, type BrowserCollectionFactory, type BrowserCollectionFindParams, type BrowserCollectionRecord, type BrowserCollections, type BrowserDataAuthMode, type BrowserRealtimeNotification, type BrowserRealtimeStatus, type BrowserRealtimeSubscribeParams, type BrowserRealtimeSubscription, type BrowserSqlExecParams, type BrowserSqlExecResult, type BrowserSqlQueryParams, type BrowserSqlQueryResult, BrowserStorageBucketClient, type BrowserStorageBulkDeleteResult, type BrowserStorageDownloadResult, type BrowserStorageItem, type BrowserStorageListResult, type BrowserStorageSignedUrlResult, type BrowserStorageUploadResult, type CollectionReturnMode, type CollectionRowData, type CollectionRowWithMeta, type CollectionWhere, type ColumnName, type ColumnValue, CookieStorageAdapter, DEFAULT_RAGABLE_API_BASE, type DefaultAuthUser, type DefaultRagableDatabase, type DefaultRagableFunctions, type FinishReason, type FunctionInvoker, type GenerateObjectResult, type GenerateTextResult, type HttpMethod, type Json, type JsonSchema, LocalStorageAdapter, type MailMessageDetail, type MailMessagePreview, type MailSearchParams, type MailSendParams, type MailSendResult, MemoryStorageAdapter, type Message, type PostgRESTFetch, type PostgRESTFetchParams, PostgrestDeleteReturningBuilder, PostgrestDeleteRootBuilder, PostgrestInsertReturningBuilder, PostgrestInsertRootBuilder, PostgrestInsertSdkErrorReturning, PostgrestInsertSdkErrorRoot, type PostgrestResult, PostgrestSelectBuilder, PostgrestTableApi, PostgrestUpdateReturningBuilder, PostgrestUpdateRootBuilder, type PostgrestUpsertOptions, PostgrestUpsertReturningBuilder, PostgrestUpsertRootBuilder, RagableAbortError, RagableAuth, type RagableAuthConfig, RagableBrowser, RagableBrowserAgentsClient, RagableBrowserAiClient, RagableBrowserAuthClient, type RagableBrowserClientOptions, RagableBrowserDatabaseClient, RagableBrowserFunctionsClient, RagableBrowserMailClient, RagableBrowserStorageClient, type RagableDatabase, RagableError, type RagableFunctionCall, type RagableFunctionContext, type RagableFunctionHandler, type RagableFunctionInvokeOptions, type RagableFunctions, RagableNetworkError, type RagableResult, RagableSdkError, type RagableTableDefinition, type RagableTableNames, RagableTimeoutError, type RequestOptions, type RetryOptions, type RunAgentChatStreamOptions, type RunQuery, type SessionStorage, SessionStorageAdapter, type SseJsonEvent, type StreamObjectParams, type StreamObjectResult, type StreamPart, type StreamTextParams, type StreamTextResult, type SupabaseCompatSession, type TableInsertRow, type TableRow, type TableUpdatePatch, type Tables, type TablesInsert, type TablesUpdate, type TokenUsage, type ToolCallRecord, Transport, type TransportOptions, type TransportRequest, type WhereInput, type WhereOperatorObject, asPostgrestResponse, assertPostgrestSuccess, bindFetch, buildInferenceRequestBody, buildResponseFormat, collectAssistantTextFromUiSegments, collectionRecordToRowWithMeta, collectionRecordsToRowWithMeta, createBrowserClient, createClient, createRagableBrowserClient, createStreamResultFromParts, detectStorage, effectiveDataAuth, extractErrorMessage, finalizeAgentChatUiTurn, foldAgentStreamIntoUiSegments, formatPostgrestError, formatSdkError, generateIdempotencyKey, isIncompleteAgentStreamError, mapAgentEvent, mapFireworksChunk, normalizeBrowserApiBase, parseAgentStreamAgentInfo, parseAgentStreamDone, parseSseDataLine, parseTransportResponse, readSseStream, runAgentChatStream, runAgentChatStreamForUi, runAgentChatStreamLenient, streamObjectFromContext, toRagableResult, tryParsePartialJson, unwrapPostgrest, wrapStreamTextAsObject };
+export { type AgentChatMessage, type AgentChatParams, type AgentChatStreamDonePayload, type AgentChatStreamHandlers, type AgentChatStreamResult, type AgentChatStreamUiHandlers, type AgentChatUiAssistantMessage, type AgentChatUiSegment, type AgentChatUiStreamResult, type AgentConversation, type AgentConversationMessage, type AgentConversationSubscription, type AgentPublicChatParams, type AgentStreamAgentInfoEvent, type AgentStreamEvent, AuthBroadcastChannel, type AuthBroadcastMessage, type AuthChangeEvent, type AuthOptions, type AuthSession, type AuthSignUpCredentials, type AuthUpdateUserAttributes, type AuthUserMetadata, type BrowserAuthSession, type BrowserAuthTokens, BrowserCollectionApi, type BrowserCollectionDefinition, type BrowserCollectionFactory, type BrowserCollectionFindParams, type BrowserCollectionRecord, type BrowserCollections, type BrowserDataAuthMode, type BrowserRealtimeNotification, type BrowserRealtimeStatus, type BrowserRealtimeSubscribeParams, type BrowserRealtimeSubscription, type BrowserSqlExecParams, type BrowserSqlExecResult, type BrowserSqlQueryParams, type BrowserSqlQueryResult, BrowserStorageBucketClient, type BrowserStorageBulkDeleteResult, type BrowserStorageDownloadResult, type BrowserStorageItem, type BrowserStorageListResult, type BrowserStorageSignedUrlResult, type BrowserStorageUploadResult, type CollectionReturnMode, type CollectionRowData, type CollectionRowWithMeta, type CollectionWhere, type ColumnName, type ColumnValue, CookieStorageAdapter, DEFAULT_RAGABLE_API_BASE, type DefaultAuthUser, type DefaultRagableDatabase, type DefaultRagableFunctions, type FinishReason, type FunctionInvoker, type GenerateObjectResult, type GenerateTextResult, type HttpMethod, type Json, type JsonSchema, LocalStorageAdapter, type MailMessageDetail, type MailMessagePreview, type MailSearchParams, type MailSendParams, type MailSendResult, MemoryStorageAdapter, type Message, type PostgRESTFetch, type PostgRESTFetchParams, PostgrestDeleteReturningBuilder, PostgrestDeleteRootBuilder, PostgrestInsertReturningBuilder, PostgrestInsertRootBuilder, PostgrestInsertSdkErrorReturning, PostgrestInsertSdkErrorRoot, type PostgrestResult, PostgrestSelectBuilder, PostgrestTableApi, PostgrestUpdateReturningBuilder, PostgrestUpdateRootBuilder, type PostgrestUpsertOptions, PostgrestUpsertReturningBuilder, PostgrestUpsertRootBuilder, RagableAbortError, RagableAuth, type RagableAuthConfig, RagableBrowser, RagableBrowserAgentsClient, RagableBrowserAiClient, RagableBrowserAuthClient, type RagableBrowserClientOptions, RagableBrowserDatabaseClient, RagableBrowserFunctionsClient, RagableBrowserMailClient, RagableBrowserStorageClient, type RagableDatabase, RagableError, type RagableFunctionCall, type RagableFunctionContext, type RagableFunctionHandler, type RagableFunctionInvokeOptions, type RagableFunctions, RagableNetworkError, type RagableResult, RagableSdkError, RagableServerClient, type RagableServerClientConfig, type RagableTableDefinition, type RagableTableNames, RagableTimeoutError, type RequestOptions, type RetryOptions, type RunAgentChatStreamOptions, type RunQuery, type ServerPrivilege, type SessionStorage, SessionStorageAdapter, type SseJsonEvent, type StreamObjectParams, type StreamObjectResult, type StreamPart, type StreamTextParams, type StreamTextResult, type SupabaseCompatSession, type TableInsertRow, type TableRow, type TableUpdatePatch, type Tables, type TablesInsert, type TablesUpdate, type TokenUsage, type ToolCallRecord, Transport, type TransportOptions, type TransportRequest, type WhereInput, type WhereOperatorObject, asPostgrestResponse, assertPostgrestSuccess, bindFetch, buildInferenceRequestBody, buildResponseFormat, collectAssistantTextFromUiSegments, collectionRecordToRowWithMeta, collectionRecordsToRowWithMeta, createBrowserClient, createClient, createRagableBrowserClient, createServerClient, createStreamResultFromParts, detectStorage, effectiveDataAuth, extractErrorMessage, finalizeAgentChatUiTurn, foldAgentStreamIntoUiSegments, formatPostgrestError, formatSdkError, generateIdempotencyKey, isIncompleteAgentStreamError, mapAgentEvent, mapFireworksChunk, normalizeBrowserApiBase, parseAgentStreamAgentInfo, parseAgentStreamDone, parseSseDataLine, parseTransportResponse, readSseStream, runAgentChatStream, runAgentChatStreamForUi, runAgentChatStreamLenient, streamObjectFromContext, toRagableResult, tryParsePartialJson, unwrapPostgrest, wrapStreamTextAsObject };