@ragable/sdk 0.7.10 → 0.8.1

package/dist/index.d.mts

@@ -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;
 }
@@ -981,53 +1014,10 @@ type StreamPart = {
     type: "error";
     error: unknown;
 };
-/** Plain text segment inside a multimodal user message. */
-interface TextPart {
-    type: "text";
-    text: string;
-}
-/**
- * Image segment inside a multimodal user message. Mirrors Vercel AI SDK's
- * `ImagePart` shape — the discriminator is `"image"` and the data field is
- * `image` (not `image_url`). The SDK converts to the OpenAI `image_url`
- * wire format internally.
- */
-interface ImagePart {
-    type: "image";
-    /**
-     * Accepted forms:
-     *  - HTTP(S) URL string (`"https://…"`) — passed through; the provider fetches it.
-     *  - Data URL string (`"data:image/png;base64,…"`) — passed through.
-     *  - Raw base64 string (no `data:` prefix) — `mediaType` then required.
-     *  - `Uint8Array` / `ArrayBuffer` — base64-encoded; `mediaType` required.
-     *  - `URL` instance — `href` is passed through.
-     */
-    image: string | Uint8Array | ArrayBuffer | URL;
-    /** IANA media type, e.g. `"image/png"`. Required when `image` is binary or a raw base64 string. */
-    mediaType?: string;
-    /** OpenAI-compatible detail hint; forwarded as `image_url.detail`. */
-    detail?: "auto" | "low" | "high";
-}
-/**
- * Content for a user message — either a plain string (back-compat with the
- * original text-only shape) or an array of text/image parts.
- */
-type UserContent = string | Array<TextPart | ImagePart>;
-/**
- * Chat message. `user` messages may carry multimodal content; `system` and
- * `assistant` are text-only (vision models consume images on user turns,
- * and image *output* isn't supported here).
- */
-type Message = {
-    role: "system";
+interface Message {
+    role: "system" | "user" | "assistant";
     content: string;
-} | {
-    role: "user";
-    content: UserContent;
-} | {
-    role: "assistant";
-    content: string;
-};
+}
 /**
  * OpenAI/Fireworks SSE chunk shape, only the fields we actually consume.
  * Kept as a local type so we don't depend on backend internals.
@@ -1289,15 +1279,117 @@ declare function streamObjectFromContext<T = unknown>(ctx: InferenceRequestConte
  */
 declare function wrapStreamTextAsObject<T = unknown>(inner: StreamTextResult): StreamObjectResult<T>;
 
+/**
+ * Backend "edge functions".
+ *
+ * A function is a single file in the project's `/functions` folder whose name is
+ * the function name and whose **default export is the handler**:
+ *
+ * ```ts
+ * // /functions/getUsers.ts
+ * import type { RagableFunctionContext } from "@ragable/sdk";
+ *
+ * export default async function getUsers(
+ *   input: { limit?: number },
+ *   context: RagableFunctionContext,
+ * ) {
+ *   const res = await fetch("https://api.example.com/users", {
+ *     headers: { Authorization: `Bearer ${context.env.API_KEY}` },
+ *   });
+ *   return (await res.json()).slice(0, input.limit ?? 20);
+ * }
+ * ```
+ *
+ * Saving the file deploys it (near-instant). It runs **server-side** — so secrets
+ * stay off the client and there are no browser CORS limits — and is invoked from
+ * the browser with `client.functions.getUsers({ limit: 5 })`.
+ *
+ * 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.
+ */
+interface RagableFunctionContext {
+    /**
+     * Secrets for this function, parsed from the project's `/functions/.env`.
+     * Server-only: this file is read at invoke time and never bundled into the
+     * browser app. Empty when no `/functions/.env` exists.
+     */
+    env: Record<string, string>;
+    /** Metadata about the invoking HTTP request. */
+    request: {
+        method: string;
+        headers: Record<string, string>;
+    };
+    /**
+     * End-user auth forwarded from the caller. `token` is the bearer the browser
+     * client was holding (an end-user access token or the data static key), or
+     * `null` for anonymous calls.
+     */
+    auth: {
+        token: string | null;
+    };
+}
+/**
+ * The shape a `/functions/<name>.ts` default export must satisfy. Type the
+ * `input` parameter as optional (`input?: Foo`) when callers may omit it.
+ */
+type RagableFunctionHandler<Input = any, Output = any> = (input: Input, context: RagableFunctionContext) => Output | Promise<Output>;
+/**
+ * A project's function map: function name → handler. Generated as `AppFunctions`.
+ * The constraint is intentionally loose (any function shape) so a handler that
+ * deviates from `(input, context)` never breaks the generated client as a whole;
+ * the per-call typing in {@link RagableFunctionCall} adapts to each signature.
+ */
+type RagableFunctions = Record<string, (...args: any[]) => any>;
+/** Permissive default used when no generated `AppFunctions` is supplied. */
+interface DefaultRagableFunctions {
+    [name: string]: (...args: any[]) => any;
+}
+/** Per-call options for an invocation. */
+interface RagableFunctionInvokeOptions {
+    signal?: AbortSignal;
+    headers?: HeadersInit;
+}
+/**
+ * The browser-side call signature derived from a server handler `H`: the server
+ * injects `context`, so the caller passes only `input`. `input` is optional when
+ * the handler's input type permits `undefined`.
+ */
+type RagableFunctionCall<H> = H extends (input: infer I, ...rest: any[]) => infer R ? undefined extends I ? (input?: I, options?: RagableFunctionInvokeOptions) => Promise<Awaited<R>> : (input: I, options?: RagableFunctionInvokeOptions) => Promise<Awaited<R>> : (input?: unknown, options?: RagableFunctionInvokeOptions) => Promise<unknown>;
+/**
+ * The type of `client.functions`: a typed callable per function in `F`, plus an
+ * `invoke(name, input?)` escape hatch for dynamic dispatch. (A function literally
+ * named `invoke` is therefore reserved.)
+ */
+type FunctionInvoker<F extends RagableFunctions = DefaultRagableFunctions> = {
+    [K in keyof F]: RagableFunctionCall<F[K]>;
+} & {
+    /** Invoke a function by name. Useful when the name is dynamic. */
+    invoke<Result = unknown>(name: string, input?: unknown, options?: RagableFunctionInvokeOptions): Promise<Result>;
+};
+
 /** 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 {
@@ -1412,6 +1504,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;
@@ -1507,6 +1605,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<{
@@ -1537,11 +1644,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).
      */
@@ -1762,10 +1869,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;
@@ -1834,7 +1955,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 {
@@ -1930,6 +2052,33 @@ declare class RagableBrowserMailClient {
     /** Fetch a single message in full (headers + decoded text/html body). */
     getMessage(messageId: string): Promise<MailMessageDetail>;
 }
+/**
+ * Invokes the project's backend edge functions (handlers in `/functions/<name>.ts`).
+ *
+ * Exposed on the client as a typed Proxy — `client.functions.<name>(input)` — so
+ * each generated function name is a direct callable. Functions run server-side,
+ * so calls can use secrets and reach any external API without browser CORS limits.
+ */
+declare class RagableBrowserFunctionsClient {
+    private readonly options;
+    private readonly auth;
+    private readonly fetchImpl;
+    constructor(options: RagableBrowserClientOptions, auth: RagableAuth | null);
+    private requireWebsiteId;
+    private toUrl;
+    /**
+     * Best-effort end-user bearer, forwarded to the function as `context.auth.token`.
+     * Functions are public, so this never throws — anonymous calls send no token.
+     */
+    private getOptionalToken;
+    /**
+     * Invoke a function by name. Prefer the typed `client.functions.<name>(input)`
+     * accessors; use this when the name is dynamic.
+     */
+    invoke<Result = unknown>(name: string, input?: unknown, options?: RagableFunctionInvokeOptions): Promise<Result>;
+    /** Build the typed Proxy exposed as `client.functions`. */
+    asInvoker<F extends RagableFunctions = DefaultRagableFunctions>(): FunctionInvoker<F>;
+}
 interface AgentConversationMessage {
     role: "user" | "assistant";
     content: string;
@@ -2062,7 +2211,7 @@ interface AgentPublicChatParams extends AgentChatParams {
     triggerSubtype?: string;
     triggerNodeId?: string;
 }
-declare class RagableBrowser<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser> {
+declare class RagableBrowser<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser, Functions extends RagableFunctions = DefaultRagableFunctions> {
     readonly agents: RagableBrowserAgentsClient;
     readonly ai: RagableBrowserAiClient;
     readonly auth: RagableBrowserAuthClient<AuthUser>;
@@ -2070,14 +2219,26 @@ declare class RagableBrowser<Database extends RagableDatabase = DefaultRagableDa
     readonly db: RagableBrowserDatabaseClient<Database>;
     readonly storage: RagableBrowserStorageClient;
     readonly mail: RagableBrowserMailClient;
+    /**
+     * Backend edge functions — call a `/functions/<name>.ts` handler with
+     * `client.functions.<name>(input)`. Runs server-side. See {@link FunctionInvoker}.
+     */
+    readonly functions: FunctionInvoker<Functions>;
     readonly transport: Transport;
     private readonly _ragableAuth;
     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>(options: RagableBrowserClientOptions): RagableBrowser<Database, AuthUser>;
+declare function createBrowserClient<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser, Functions extends RagableFunctions = DefaultRagableFunctions>(options: RagableBrowserClientOptions): RagableBrowser<Database, AuthUser, Functions>;
 declare const createRagableBrowserClient: typeof createBrowserClient;
 
 /**
@@ -2092,45 +2253,6 @@ declare function parseSseDataLine(line: string): SseJsonEvent | null;
  */
 declare function readSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<SseJsonEvent, void, undefined>;
 
-/**
- * Convert SDK-shape multimodal content to the OpenAI/Fireworks `image_url`
- * wire format the Ragable inference proxy expects. Keeps the public SDK
- * types Vercel-AI-SDK-shaped (`{ type: "image", image: ... }`) while the
- * over-the-wire shape stays OpenAI canonical.
- */
-
-/** OpenAI/Fireworks image content part — what flows on the wire. */
-interface WireImagePart {
-    type: "image_url";
-    image_url: {
-        url: string;
-        detail?: "auto" | "low" | "high";
-    };
-}
-type WireTextPart = {
-    type: "text";
-    text: string;
-};
-type WireContentPart = WireTextPart | WireImagePart;
-type WireUserContent = string | WireContentPart[];
-/**
- * Convert a single `UserContent` value to wire shape. Strings pass through
- * unchanged so existing callers keep producing byte-identical request bodies.
- */
-declare function toWireUserContent(content: UserContent): WireUserContent;
-/**
- * Resolve an `ImagePart.image` value into a URL string suitable for
- * `image_url.url`. URLs pass through; binary and raw base64 are wrapped
- * into a data URL.
- */
-declare function imagePartToUrl(part: ImagePart): string;
-/**
- * Cross-runtime `Uint8Array → base64`. `btoa(String.fromCharCode(...bytes))`
- * trips the JS call-stack limit on large payloads, so we chunk the binary
- * string. Works in browser, Node 18+, Edge, and Bun.
- */
-declare function bytesToBase64(bytes: Uint8Array): string;
-
 /**
  * Best-effort parser for incomplete JSON streamed token-by-token from an LLM.
  *
@@ -2147,6 +2269,6 @@ declare function bytesToBase64(bytes: Uint8Array): string;
  */
 declare function tryParsePartialJson(text: string): unknown | undefined;
 
-declare function createClient<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser>(options: RagableBrowserClientOptions): RagableBrowser<Database, AuthUser>;
+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 FinishReason, type GenerateObjectResult, type GenerateTextResult, type HttpMethod, type ImagePart, 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, RagableBrowserMailClient, RagableBrowserStorageClient, type RagableDatabase, RagableError, 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 TextPart, type TokenUsage, type ToolCallRecord, Transport, type TransportOptions, type TransportRequest, type UserContent, type WhereInput, type WhereOperatorObject, type WireContentPart, type WireImagePart, type WireTextPart, type WireUserContent, asPostgrestResponse, assertPostgrestSuccess, bindFetch, buildInferenceRequestBody, buildResponseFormat, bytesToBase64, collectAssistantTextFromUiSegments, collectionRecordToRowWithMeta, collectionRecordsToRowWithMeta, createBrowserClient, createClient, createRagableBrowserClient, createStreamResultFromParts, detectStorage, effectiveDataAuth, extractErrorMessage, finalizeAgentChatUiTurn, foldAgentStreamIntoUiSegments, formatPostgrestError, formatSdkError, generateIdempotencyKey, imagePartToUrl, isIncompleteAgentStreamError, mapAgentEvent, mapFireworksChunk, normalizeBrowserApiBase, parseAgentStreamAgentInfo, parseAgentStreamDone, parseSseDataLine, parseTransportResponse, readSseStream, runAgentChatStream, runAgentChatStreamForUi, runAgentChatStreamLenient, streamObjectFromContext, toRagableResult, toWireUserContent, 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, 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 };