@ragable/sdk 0.7.6 → 0.7.7

package/dist/index.d.ts

@@ -76,11 +76,6 @@ type ColumnValue<D extends RagableDatabase, T extends RagableTableNames<D>, C ex
 declare function bindFetch(custom?: typeof fetch): typeof fetch;
 /** Hosted Ragable HTTP API base (`…/api`) — used by all SDK clients (not configurable). */
 declare const DEFAULT_RAGABLE_API_BASE = "https://ragable-341305259977.asia-southeast1.run.app/api";
-interface RagableClientOptions {
-    apiKey: string;
-    fetch?: typeof fetch;
-    headers?: HeadersInit;
-}
 type RequestOptions = Omit<RequestInit, "body"> & {
     body?: unknown;
 };
@@ -124,116 +119,20 @@ declare class RagableTimeoutError extends RagableSdkError {
     toJSON(): Record<string, unknown>;
 }
 declare function extractErrorMessage(payload: unknown, fallback: string): string;
-declare class RagableRequestClient {
-    private readonly apiKey;
-    private readonly baseUrl;
-    private readonly fetchImpl;
-    private readonly defaultHeaders;
-    constructor(options: RagableClientOptions);
-    toUrl(path: string): string;
-    request<T>(path: string, options?: RequestOptions): Promise<T>;
-    /**
-     * Low-level fetch with API key and JSON body encoding. Caller handles status and body.
-     */
-    rawFetch(path: string, options?: RequestOptions): Promise<Response>;
-    private parseResponseBody;
-}
 
-interface ShiftIndex {
-    id: string;
-    name: string;
-    description: string | null;
-    dimensions: number;
-    embeddingModel: string;
-    status: string;
-    entryCount?: number;
-    createdAt: string;
-    updatedAt: string;
-}
-interface ShiftEntry {
-    id: string;
-    content: string;
-    metadata: unknown;
-    chunkIndex: number;
-    createdAt: string;
-}
-interface ShiftSearchResult {
+interface AgentChatMessage {
+    role: "user" | "assistant";
     content: string;
-    score: number;
-    metadata: unknown;
 }
-interface ShiftCreateIndexParams {
-    name: string;
-    description?: string;
-    dimensions?: number;
-    embeddingModel?: string;
-}
-interface ShiftUpdateIndexParams {
-    name?: string;
-    description?: string;
-}
-interface ShiftAddDocumentParams {
-    content: string;
-    metadata?: Record<string, unknown>;
-    chunkSize?: number;
-    chunkOverlap?: number;
-}
-type ShiftUploadableFile = Blob | ArrayBuffer | Uint8Array;
-interface ShiftUploadFileParams {
-    file: ShiftUploadableFile;
-    fileName?: string;
-    contentType?: string;
-    metadata?: Record<string, unknown>;
-    chunkSize?: number;
-    chunkOverlap?: number;
-}
-interface ShiftListEntriesParams {
-    take?: number;
-    skip?: number;
-}
-interface ShiftSearchParams {
-    query: string;
-    topK?: number;
-}
-interface ShiftIngestResponse {
-    chunksCreated: number;
-    entries: string[];
-    extractedText?: string;
-    message?: string;
-}
-interface ShiftListEntriesResponse {
-    entries: ShiftEntry[];
-    total: number;
-}
-declare class ShiftClient {
-    private readonly client;
-    readonly indexes: {
-        list: () => Promise<{
-            indexes: ShiftIndex[];
-        }>;
-        create: (params: ShiftCreateIndexParams) => Promise<ShiftIndex>;
-        get: (indexId: string) => Promise<ShiftIndex>;
-        update: (indexId: string, params: ShiftUpdateIndexParams) => Promise<ShiftIndex>;
-        delete: (indexId: string) => Promise<{
-            success: true;
-        }>;
-    };
-    readonly documents: {
-        create: (indexId: string, params: ShiftAddDocumentParams) => Promise<ShiftIngestResponse>;
-        upload: (indexId: string, params: ShiftUploadFileParams) => Promise<ShiftIngestResponse>;
-    };
-    readonly entries: {
-        list: (indexId: string, params?: ShiftListEntriesParams) => Promise<ShiftListEntriesResponse>;
-        delete: (indexId: string, entryId: string) => Promise<{
-            success: true;
-        }>;
-    };
-    constructor(client: RagableRequestClient);
-    search(indexId: string, params: ShiftSearchParams): Promise<{
-        results: ShiftSearchResult[];
-    }>;
+interface AgentChatParams {
+    message: string;
+    history?: AgentChatMessage[];
+    /** Passed to `fetch` — aborts the HTTP request and SSE body. */
+    signal?: AbortSignal;
 }
-
+type AgentStreamEvent = Record<string, unknown> & {
+    type: string;
+};
 /**
  * First SSE frame for website project agents (`POST …/agents/:name/chat/stream`).
  */
@@ -477,61 +376,6 @@ declare function finalizeAgentChatUiTurn(segments: AgentChatUiSegment[], done: A
  */
 declare function runAgentChatStreamForUi(source: AsyncIterable<AgentStreamEvent>, handlers?: AgentChatStreamUiHandlers, options?: RunAgentChatStreamOptions): Promise<AgentChatUiStreamResult>;
 
-interface AgentSummary {
-    id: string;
-    name: string;
-    description: string | null;
-    active: boolean;
-    createdAt: string;
-    updatedAt: string;
-}
-interface AgentChatMessage {
-    role: "user" | "assistant";
-    content: string;
-}
-interface AgentChatParams {
-    message: string;
-    history?: AgentChatMessage[];
-    /** Passed to `fetch` — aborts the HTTP request and SSE body. */
-    signal?: AbortSignal;
-}
-/** Mirrors backend ExecutionResult JSON shape (traces are opaque in the SDK). */
-interface AgentChatResult {
-    response: string;
-    traces: unknown[];
-    totalDurationMs: number;
-    httpResponse?: unknown;
-}
-/**
- * Loose SSE event from POST /v1/agents/:id/chat/stream — narrows with `type` at runtime.
- */
-type AgentStreamEvent = Record<string, unknown> & {
-    type: string;
-};
-declare class AgentsClient {
-    private readonly client;
-    constructor(client: RagableRequestClient);
-    list(): Promise<{
-        agents: AgentSummary[];
-    }>;
-    get(agentId: string): Promise<AgentSummary>;
-    chat(agentId: string, params: AgentChatParams): Promise<AgentChatResult>;
-    /**
-     * Stream agent execution as SSE (`data: {json}` lines). Yields parsed JSON objects.
-     */
-    chatStream(agentId: string, params: AgentChatParams): AsyncGenerator<AgentStreamEvent, void, undefined>;
-    /**
-     * Stream an agent turn with callbacks; returns the final `done` payload plus streamed text.
-     * Prefer this over manual iteration when building chat UIs against the server API key client.
-     */
-    runChatStream(agentId: string, params: AgentChatParams, handlers?: AgentChatStreamHandlers): Promise<AgentChatStreamResult>;
-    /**
-     * Stream with dashboard-style `AgentChat` ergonomics: {@link AgentChatStreamUiHandlers.onSegments}
-     * / `onStreamingText` for live UI; returns a persisted-shaped assistant message on `done`.
-     */
-    runChatUi(agentId: string, params: AgentChatParams, handlers?: AgentChatStreamUiHandlers): Promise<AgentChatUiStreamResult>;
-}
-
 /** @deprecated Kept for backward compat with `database.query()`. Not used by PostgREST path. */
 interface BrowserSqlExecParams {
     databaseInstanceId: string;
@@ -1098,6 +942,191 @@ declare class Transport {
 }
 declare function parseTransportResponse<T>(response: Response): Promise<T>;
 
+/**
+ * Vercel AI SDK–style stream part types, used by both `client.ai.streamText`
+ * (Fireworks chunks via the Ragable proxy) and `client.agents.run` (existing
+ * agent SSE events). Keep this module zero-dep so it can be re-exported from
+ * the SDK entrypoint without dragging in agent/browser code.
+ */
+type FinishReason = "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown";
+interface TokenUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    /** Prompt-cache read tokens reported by the upstream provider, when available. */
+    cachedPromptTokens?: number;
+}
+type StreamPart = {
+    type: "text-delta";
+    textDelta: string;
+} | {
+    type: "reasoning";
+    textDelta: string;
+} | {
+    type: "tool-call";
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+} | {
+    type: "tool-result";
+    toolCallId: string;
+    toolName: string;
+    result: unknown;
+    durationMs?: number;
+} | {
+    type: "finish";
+    finishReason: FinishReason;
+    usage: TokenUsage;
+} | {
+    type: "error";
+    error: unknown;
+};
+interface Message {
+    role: "system" | "user" | "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.
+ */
+interface OpenAiStreamChunk {
+    choices?: Array<{
+        delta?: {
+            content?: string | null;
+            reasoning_content?: string | null;
+            reasoning?: string | null;
+            tool_calls?: Array<{
+                index?: number;
+                id?: string | null;
+                type?: string;
+                function?: {
+                    name?: string | null;
+                    arguments?: string | null;
+                };
+            }>;
+        };
+        finish_reason?: string | null;
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+        total_tokens?: number;
+        prompt_tokens_details?: {
+            cached_tokens?: number;
+        };
+        cache_read_input_tokens?: number;
+    };
+    error?: {
+        code?: number;
+        message?: string;
+    };
+}
+/**
+ * Accumulator for partial tool-call function arguments streamed across
+ * multiple chunks (Fireworks streams the `arguments` JSON token-by-token).
+ */
+interface ToolCallAccumulator {
+    byIndex: Map<number, {
+        id: string;
+        name: string;
+        argsBuffer: string;
+        emitted: boolean;
+    }>;
+}
+/**
+ * Map a single Fireworks/OpenAI chunk into zero or more StreamParts.
+ * Tool calls are buffered until their `arguments` JSON is parseable, then
+ * emitted as a single `tool-call` part — same convention as Vercel AI SDK.
+ */
+declare function mapFireworksChunk(chunk: OpenAiStreamChunk, acc: ToolCallAccumulator): StreamPart[];
+/**
+ * Minimal shape of an `AgentStreamEvent` from `agent-stream.ts`. Inlined to
+ * keep this module zero-import.
+ */
+interface AgentStreamLikeEvent {
+    type: string;
+    [k: string]: unknown;
+}
+/**
+ * Map an existing agent SSE event (`token`, `reasoning_token`, `tool:call`,
+ * `tool:result`, `done`) into a StreamPart, or `null` for events that don't
+ * map (`ping`, `agent:info`, `node:*`).
+ */
+declare function mapAgentEvent(event: AgentStreamLikeEvent): StreamPart | null;
+
+/**
+ * Vercel AI SDK–style raw inference for `@ragable/sdk`. Routes through the
+ * Ragable backend's Fireworks proxy
+ * (`POST /public/organizations/:id/websites/:websiteId/inference/stream`)
+ * so callers don't need a provider API key and credit usage is tracked
+ * against the website's organization.
+ */
+
+interface StreamTextParams {
+    model: string;
+    messages: Message[];
+    system?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    reasoningEffort?: "none" | "low" | "medium" | "high";
+    signal?: AbortSignal;
+}
+interface ToolCallRecord {
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}
+interface StreamTextResult {
+    /** Stream of text deltas only. Same content as `fullStream.filter(p => p.type === "text-delta")`. */
+    textStream: AsyncIterable<string>;
+    /** Full event stream — text deltas, reasoning, tool calls, finish, error. */
+    fullStream: AsyncIterable<StreamPart>;
+    /** Resolves to the concatenation of all `text-delta` parts once the stream finishes. */
+    text: Promise<string>;
+    /** Resolves to the concatenation of all `reasoning` parts. */
+    reasoning: Promise<string>;
+    /** Resolves to token usage from the final chunk (zeros if not reported). */
+    usage: Promise<TokenUsage>;
+    /** Resolves to the upstream finish reason. */
+    finishReason: Promise<FinishReason>;
+    /** Resolves to the list of tool calls extracted from this turn. */
+    toolCalls: Promise<ToolCallRecord[]>;
+}
+interface GenerateTextResult {
+    text: string;
+    reasoning: string;
+    usage: TokenUsage;
+    finishReason: FinishReason;
+    toolCalls: ToolCallRecord[];
+}
+/**
+ * Build the JSON body for the inference proxy. Public so tests can assert it.
+ */
+declare function buildInferenceRequestBody(params: StreamTextParams): Record<string, unknown>;
+/**
+ * Build a `StreamTextResult` from a pre-existing async iterable of StreamParts.
+ * Used by `client.agents.run()` to share the same DX as `client.ai.streamText`.
+ */
+declare function createStreamResultFromParts(source: AsyncIterable<StreamPart>): StreamTextResult;
+interface AiClientOptions {
+    organizationId: string;
+    websiteId?: string;
+    fetch?: typeof fetch;
+    headers?: HeadersInit;
+    /** API base override; defaults to the shared SDK base. */
+    apiBase: string;
+}
+declare class RagableBrowserAiClient {
+    private readonly options;
+    private readonly fetchImpl;
+    constructor(options: AiClientOptions);
+    private requireWebsiteId;
+    private buildContext;
+    streamText(params: StreamTextParams): StreamTextResult;
+    generateText(params: StreamTextParams): Promise<GenerateTextResult>;
+}
+
 /** Canonical browser/server API base (`…/api`, no trailing slash). */
 declare function normalizeBrowserApiBase(): string;
 type BrowserDataAuthMode = "user" | "publicAnon" | "admin";
@@ -1674,10 +1703,33 @@ declare class RagableBrowserAgentsClient {
     private requestJson;
     /** @deprecated Prefer `chatStreamByName(agentName, params)` for project-local `/agents/*.json` agents. */
     chatStream(agentId: string, params: AgentPublicChatParams): AsyncGenerator<AgentStreamEvent, void, undefined>;
+    /**
+     * Stream a project agent defined in `agents/*.json` using the same result
+     * shape as `client.ai.streamText`. Preferred over {@link chatStreamByName}
+     * and {@link runChatStreamByName} — those remain for back-compat only.
+     *
+     * ```ts
+     * const { textStream, text } = client.agents.run("support", {
+     *   messages: [{ role: "user", content: "I can't log in" }],
+     * });
+     * for await (const delta of textStream) process.stdout.write(delta);
+     * console.log(await text);
+     * ```
+     */
+    run(agentName: string, params: {
+        messages: Message[];
+        signal?: AbortSignal;
+    }): StreamTextResult;
+    private runStreamParts;
+    /**
+     * @deprecated Use {@link run} for new code. This method is kept for
+     *   back-compat with the original chat-stream DX.
+     */
     chatStreamByName(agentName: string, params: AgentChatParams): AsyncGenerator<AgentStreamEvent, void, undefined>;
     /**
-     * Stream a project agent (`/agents/*.json`) with callbacks; returns the final `done` payload
-     * plus streamed assistant text. Prefer this over manual `for await` when building chat UIs.
+     * @deprecated Use {@link run} for new code. Returns the legacy callback-based
+     *   result type leaking server internals; the new Vercel-style API exposes
+     *   `textStream` / `fullStream` / promises for `text`, `usage`, `finishReason`.
      */
     runChatStreamByName(agentName: string, params: AgentChatParams, handlers?: AgentChatStreamHandlers): Promise<AgentChatStreamResult>;
     /**
@@ -1711,6 +1763,7 @@ interface AgentPublicChatParams extends AgentChatParams {
 }
 declare class RagableBrowser<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser> {
     readonly agents: RagableBrowserAgentsClient;
+    readonly ai: RagableBrowserAiClient;
     readonly auth: RagableBrowserAuthClient<AuthUser>;
     readonly database: RagableBrowserDatabaseClient<Database>;
     readonly db: RagableBrowserDatabaseClient<Database>;
@@ -1737,366 +1790,6 @@ declare function parseSseDataLine(line: string): SseJsonEvent | null;
  */
 declare function readSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<SseJsonEvent, void, undefined>;
 
-/** Minimal client surface for {@link createRagPipeline} (implemented by {@link Ragable}). */
-interface RagClientForPipeline {
-    shift: {
-        documents: {
-            create: (indexId: string, params: ShiftAddDocumentParams) => Promise<ShiftIngestResponse>;
-            upload: (indexId: string, params: ShiftUploadFileParams) => Promise<ShiftIngestResponse>;
-        };
-        search: (indexId: string, params: ShiftSearchParams) => Promise<{
-            results: ShiftSearchResult[];
-        }>;
-    };
-}
-interface FormatContextOptions {
-    /** Prepended before numbered passages (default: "Relevant passages:\\n") */
-    header?: string;
-    /** Joiner between passages (default: "\\n\\n") */
-    separator?: string;
-    /** Omit results with similarity score below this (default: no filter) */
-    minScore?: number;
-    /** Truncate total context string to this UTF-16 length (default: no limit) */
-    maxChars?: number;
-    /** Include similarity score in each block (default: false) */
-    includeScores?: boolean;
-}
-interface RagPipelineOptions {
-    indexId: string;
-}
-type RetrieveParams = ShiftSearchParams & {
-    format?: FormatContextOptions;
-};
-interface RagPipeline {
-    readonly indexId: string;
-    ingestText(params: ShiftAddDocumentParams): Promise<ShiftIngestResponse>;
-    ingestFile(params: ShiftUploadFileParams): Promise<ShiftIngestResponse>;
-    search(params: ShiftSearchParams): Promise<{
-        results: ShiftSearchResult[];
-    }>;
-    retrieve(params: RetrieveParams): Promise<{
-        results: ShiftSearchResult[];
-        context: string;
-    }>;
-}
-/**
- * Turn vector search hits into a single block of text for system prompts or RAG user messages.
- */
-declare function formatRetrievalContext(results: ShiftSearchResult[], options?: FormatContextOptions): string;
-/**
- * High-level RAG helpers bound to one Shift index: ingest, search, retrieve with prompt-ready context.
- */
-declare function createRagPipeline(client: RagClientForPipeline, options: RagPipelineOptions): RagPipeline;
-
-interface StorageBucket {
-    id: string;
-    name: string;
-    organizationId: string;
-    status: string;
-    createdAt: string;
-    updatedAt: string;
-}
-interface StorageBucketItem {
-    type: "file" | "folder";
-    path: string;
-    name: string;
-    /** File size in bytes (files only). */
-    size?: string | null;
-    contentType?: string | null;
-    updated?: string | null;
-    generation?: string | null;
-}
-interface StorageListContentsResult {
-    bucket: string;
-    prefix: string;
-    items: StorageBucketItem[];
-    nextPageToken: string | null;
-}
-interface StorageListBucketsParams {
-    /** Filter by name substring. */
-    q?: string;
-    status?: string;
-    sort?: string;
-}
-interface StorageListContentsParams {
-    /** Folder prefix to list inside (e.g. `"reports/"`). */
-    prefix?: string;
-    /** Path delimiter — defaults to `"/"` on the server. */
-    delimiter?: string;
-    maxResults?: number;
-    pageToken?: string;
-}
-type StorageUploadableFile = Blob | ArrayBuffer | Uint8Array;
-interface StorageUploadParams {
-    /** Target path inside the bucket (e.g. `"reports/jan.pdf"`). */
-    objectPath: string;
-    file: StorageUploadableFile;
-    /** Optional filename hint for content-type detection. */
-    fileName?: string;
-    contentType?: string;
-    /** HTTP `Cache-Control` header stored with the object. */
-    cacheControl?: string;
-}
-interface StorageUploadResult {
-    success: true;
-    path: string;
-    size: string | null;
-    contentType: string | null;
-    generation: string | null;
-    updated: string | null;
-}
-interface StorageDownloadParams {
-    objectPath: string;
-    /** When `true`, the response includes `text` if the file fits in `maxTextBytes`. */
-    asText?: boolean;
-    /** Maximum bytes to decode as text (default 1 MB, max 5 MB). */
-    maxTextBytes?: number;
-}
-interface StorageDownloadResult {
-    path: string;
-    size: string | null;
-    contentType: string | null;
-    updated: string | null;
-    generation: string | null;
-    /** Always `"base64"`. */
-    encoding: string;
-    /** Full file contents encoded as base64. */
-    contentsBase64: string;
-    /** UTF-8 decoded text when `asText: true` and size ≤ `maxTextBytes`. */
-    text: string | null;
-    textIncluded: boolean;
-}
-interface StorageObjectMetadata {
-    name: string;
-    bucket: string;
-    contentType: string | null;
-    size: string | null;
-    updated: string | null;
-    generation: string | null;
-    metadata?: Record<string, string>;
-    [key: string]: unknown;
-}
-interface StorageUpdateMetadataParams {
-    objectPath: string;
-    contentType?: string;
-    cacheControl?: string;
-    metadata?: Record<string, string>;
-}
-interface StorageCopyMoveParams {
-    sourcePath: string;
-    destinationPath: string;
-}
-interface StorageBulkDeleteResult {
-    success: boolean;
-    totalRequested: number;
-    uniquePaths: number;
-    deleted: string[];
-    errors: Array<{
-        path: string;
-        error: string;
-    }>;
-}
-interface StorageSignedUploadUrlParams {
-    objectPath: string;
-    /** Expiry in seconds — clamped to [60, 3600] by the server. Default 900. */
-    expiresInSeconds?: number;
-    contentType?: string;
-}
-interface StorageSignedUploadUrlResult {
-    url: string;
-    method: string;
-    expiresInSeconds: number;
-    objectPath: string;
-}
-interface StorageSignedDownloadUrlParams {
-    objectPath: string;
-    /** Expiry in seconds — clamped to [60, 86400] by the server. Default 900. */
-    expiresInSeconds?: number;
-}
-interface StorageSignedDownloadUrlResult {
-    url: string;
-    method: string;
-    expiresInSeconds: number;
-    objectPath: string;
-}
-interface StorageBucketCorsEntry {
-    origin?: string[];
-    method?: string[];
-    responseHeader?: string[];
-    maxAgeSeconds?: number;
-}
-interface StorageBucketSettings {
-    id: string;
-    logicalName: string;
-    gcpBucketName: string;
-    location: string | null;
-    storageClass: string | null;
-    labels: Record<string, string>;
-    versioningEnabled: boolean;
-    publicAccessPrevention: string | null;
-    uniformBucketLevelAccessEnabled: boolean;
-    cors: StorageBucketCorsEntry[];
-    retentionPolicy: unknown;
-    lifecycleRules: unknown[];
-    updated: string | null;
-}
-interface StorageUpdateBucketSettingsParams {
-    labels?: Record<string, string>;
-    storageClass?: string;
-    versioningEnabled?: boolean;
-    publicAccessPrevention?: "inherited" | "enforced";
-    uniformBucketLevelAccessEnabled?: boolean;
-    cors?: StorageBucketCorsEntry[];
-}
-/**
- * Object/file operations scoped to a single bucket.
- * Obtained via {@link StorageClient.from}.
- *
- * @example
- * const bucket = ragable.storage.from("bucket-id");
- *
- * // Upload a file
- * await bucket.upload({ objectPath: "data/report.pdf", file: pdfBlob });
- *
- * // Download and read as text
- * const { text } = await bucket.download({ objectPath: "data/notes.txt", asText: true });
- *
- * // Generate a short-lived public download link
- * const { url } = await bucket.getSignedDownloadUrl({ objectPath: "data/report.pdf" });
- */
-interface StorageBucketClient {
-    /** List objects and sub-folders inside this bucket (optionally under a prefix). */
-    list(params?: StorageListContentsParams): Promise<StorageListContentsResult>;
-    /** Create an empty folder placeholder (GCS folder marker). */
-    createFolder(folderPath: string): Promise<{
-        success: true;
-        folderPath: string;
-    }>;
-    /** Delete a folder and all objects under it. */
-    deleteFolder(folderPath: string): Promise<{
-        success: true;
-        folderPath: string;
-    }>;
-    /** Upload a file to the specified `objectPath`. */
-    upload(params: StorageUploadParams): Promise<StorageUploadResult>;
-    /** Delete a single object. */
-    delete(objectPath: string): Promise<{
-        success: true;
-        path: string;
-    }>;
-    /** Delete up to 1 000 objects in one call. */
-    bulkDelete(objectPaths: string[]): Promise<StorageBulkDeleteResult>;
-    /** Retrieve GCS metadata for an object. */
-    getMetadata(objectPath: string): Promise<StorageObjectMetadata>;
-    /** Update `contentType`, `cacheControl`, or custom `metadata` for an object. */
-    updateMetadata(params: StorageUpdateMetadataParams): Promise<StorageObjectMetadata>;
-    /**
-     * Download an object. Contents are always returned as `contentsBase64`.
-     * Pass `asText: true` to also receive a decoded `text` field (≤ maxTextBytes).
-     */
-    download(params: StorageDownloadParams): Promise<StorageDownloadResult>;
-    /** Copy an object to a new path inside the same bucket. */
-    copy(params: StorageCopyMoveParams): Promise<{
-        success: true;
-        sourcePath: string;
-        destinationPath: string;
-    }>;
-    /** Move (rename) an object inside the same bucket. */
-    move(params: StorageCopyMoveParams): Promise<{
-        success: true;
-        sourcePath: string;
-        destinationPath: string;
-    }>;
-    /**
-     * Generate a signed URL for direct client-side PUT upload (bypasses your server).
-     * Use this when a website needs to upload large files directly to GCS.
-     */
-    getSignedUploadUrl(params: StorageSignedUploadUrlParams): Promise<StorageSignedUploadUrlResult>;
-    /**
-     * Generate a signed URL for direct client-side download.
-     * Useful for serving private files without proxying through your server.
-     */
-    getSignedDownloadUrl(params: StorageSignedDownloadUrlParams): Promise<StorageSignedDownloadUrlResult>;
-    /** Retrieve GCS-level settings for this bucket (CORS, versioning, storage class …). */
-    getSettings(): Promise<StorageBucketSettings>;
-    /** Update GCS-level settings for this bucket. */
-    updateSettings(params: StorageUpdateBucketSettingsParams): Promise<StorageBucketSettings>;
-}
-/**
- * Server-side storage client — access via `ragable.storage`.
- *
- * Manages GCS-backed storage buckets for your organisation and exposes typed
- * helpers for every object-storage operation websites need for durable storage.
- *
- * ```ts
- * import { createClient } from "@ragable/sdk";
- *
- * const ragable = createClient({ apiKey: process.env.RAGABLE_API_KEY! });
- *
- * // ── Bucket management ───────────────────────────────────────────────────
- * const buckets = await ragable.storage.buckets.list();
- * const bucket  = await ragable.storage.buckets.create("my-website-assets");
- *
- * // ── Object operations (via .from()) ─────────────────────────────────────
- * const b = ragable.storage.from(bucket.id);
- *
- * await b.upload({ objectPath: "pages/index.html", file: htmlBlob, contentType: "text/html" });
- * const { text } = await b.download({ objectPath: "pages/index.html", asText: true });
- *
- * // ── Signed URLs for client-side direct upload/download ──────────────────
- * const { url } = await b.getSignedUploadUrl({ objectPath: "uploads/photo.jpg", contentType: "image/jpeg" });
- * ```
- */
-declare class StorageClient {
-    private readonly client;
-    /**
-     * Bucket-level CRUD — list, create and delete buckets for this organisation.
-     */
-    readonly buckets: {
-        /**
-         * List all managed storage buckets.
-         *
-         * @param params Optional filter / sort params (`q`, `status`, `sort`).
-         */
-        list(params?: StorageListBucketsParams): Promise<StorageBucket[]>;
-        /**
-         * Create a new managed GCS bucket.
-         *
-         * The `name` must be lowercase alphanumeric + dashes, max 63 chars.
-         */
-        create(name: string): Promise<StorageBucket>;
-        /**
-         * Permanently delete a bucket and **all** its contents.
-         *
-         * @param bucketId The Ragable bucket ID (not the raw GCS bucket name).
-         */
-        delete(bucketId: string): Promise<{
-            success: true;
-        }>;
-    };
-    constructor(client: RagableRequestClient);
-    /**
-     * Returns a {@link StorageBucketClient} scoped to the given bucket ID.
-     *
-     * All object operations (upload, download, list, copy, move, signed URLs, …)
-     * are performed through the returned client.
-     *
-     * @param bucketId The Ragable bucket ID obtained from `buckets.list()` or `buckets.create()`.
-     */
-    from(bucketId: string): StorageBucketClient;
-}
-
-declare class Ragable {
-    readonly shift: ShiftClient;
-    readonly agents: AgentsClient;
-    readonly storage: StorageClient;
-    readonly infrastructure: {
-        shift: ShiftClient;
-    };
-    constructor(options: RagableClientOptions);
-}
-declare function createClient(options: RagableClientOptions): Ragable;
 declare function createClient<Database extends RagableDatabase = DefaultRagableDatabase, AuthUser extends object = DefaultAuthUser>(options: RagableBrowserClientOptions): RagableBrowser<Database, AuthUser>;
-declare function createRagableServerClient(options: RagableClientOptions): Ragable;
 
-export { type AgentChatMessage, type AgentChatParams, type AgentChatResult, 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, type AgentSummary, AgentsClient, 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, type CollectionReturnMode, type CollectionRowData, type CollectionRowWithMeta, type CollectionWhere, type ColumnName, type ColumnValue, CookieStorageAdapter, DEFAULT_RAGABLE_API_BASE, type DefaultAuthUser, type DefaultRagableDatabase, type FormatContextOptions, type HttpMethod, type Json, LocalStorageAdapter, MemoryStorageAdapter, type PostgRESTFetch, type PostgRESTFetchParams, PostgrestDeleteReturningBuilder, PostgrestDeleteRootBuilder, PostgrestInsertReturningBuilder, PostgrestInsertRootBuilder, PostgrestInsertSdkErrorReturning, PostgrestInsertSdkErrorRoot, type PostgrestResult, PostgrestSelectBuilder, PostgrestTableApi, PostgrestUpdateReturningBuilder, PostgrestUpdateRootBuilder, type PostgrestUpsertOptions, PostgrestUpsertReturningBuilder, PostgrestUpsertRootBuilder, type RagClientForPipeline, type RagPipeline, type RagPipelineOptions, Ragable, RagableAbortError, RagableAuth, type RagableAuthConfig, RagableBrowser, RagableBrowserAgentsClient, RagableBrowserAuthClient, type RagableBrowserClientOptions, RagableBrowserDatabaseClient, type RagableClientOptions, type RagableDatabase, RagableError, RagableNetworkError, RagableRequestClient, type RagableResult, RagableSdkError, type RagableTableDefinition, type RagableTableNames, RagableTimeoutError, type RequestOptions, type RetrieveParams, type RetryOptions, type RunAgentChatStreamOptions, type RunQuery, type SessionStorage, SessionStorageAdapter, type ShiftAddDocumentParams, ShiftClient, type ShiftCreateIndexParams, type ShiftEntry, type ShiftIndex, type ShiftIngestResponse, type ShiftListEntriesParams, type ShiftListEntriesResponse, type ShiftSearchParams, type ShiftSearchResult, type ShiftUpdateIndexParams, type ShiftUploadFileParams, type ShiftUploadableFile, type SseJsonEvent, type StorageBucket, type StorageBucketClient, type StorageBucketCorsEntry, type StorageBucketItem, type StorageBucketSettings, type StorageBulkDeleteResult, StorageClient, type StorageCopyMoveParams, type StorageDownloadParams, type StorageDownloadResult, type StorageListBucketsParams, type StorageListContentsParams, type StorageListContentsResult, type StorageObjectMetadata, type StorageSignedDownloadUrlParams, type StorageSignedDownloadUrlResult, type StorageSignedUploadUrlParams, type StorageSignedUploadUrlResult, type StorageUpdateBucketSettingsParams, type StorageUpdateMetadataParams, type StorageUploadParams, type StorageUploadResult, type StorageUploadableFile, type SupabaseCompatSession, type TableInsertRow, type TableRow, type TableUpdatePatch, type Tables, type TablesInsert, type TablesUpdate, Transport, type TransportOptions, type TransportRequest, type WhereInput, type WhereOperatorObject, asPostgrestResponse, assertPostgrestSuccess, bindFetch, collectAssistantTextFromUiSegments, collectionRecordToRowWithMeta, collectionRecordsToRowWithMeta, createBrowserClient, createClient, createRagPipeline, createRagableBrowserClient, createRagableServerClient, detectStorage, effectiveDataAuth, extractErrorMessage, finalizeAgentChatUiTurn, foldAgentStreamIntoUiSegments, formatPostgrestError, formatRetrievalContext, formatSdkError, generateIdempotencyKey, isIncompleteAgentStreamError, normalizeBrowserApiBase, parseAgentStreamAgentInfo, parseAgentStreamDone, parseSseDataLine, parseTransportResponse, readSseStream, runAgentChatStream, runAgentChatStreamForUi, runAgentChatStreamLenient, toRagableResult, unwrapPostgrest };
+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 GenerateTextResult, type HttpMethod, type Json, LocalStorageAdapter, 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, 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 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, 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, toRagableResult, unwrapPostgrest };