@ragable/sdk 0.7.6 → 0.7.8

package/dist/index.d.mts

@@ -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,310 @@ 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.
+ */
+
+/** JSON Schema for a structured response. Plain object — no Zod dep. */
+type JsonSchema = Record<string, unknown>;
+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[];
+}
+interface StreamObjectParams {
+    model: string;
+    /**
+     * JSON Schema describing the expected output. Constrains the model via the
+     * Fireworks `response_format: { type: "json_object", schema }` mode.
+     */
+    schema: JsonSchema;
+    /** Optional name for the schema (passed through to providers that support it). */
+    schemaName?: string;
+    /** Optional natural-language description of the schema. */
+    schemaDescription?: string;
+    messages: Message[];
+    system?: string;
+    temperature?: number;
+    maxTokens?: number;
+    topP?: number;
+    signal?: AbortSignal;
+}
+interface StreamObjectResult<T = unknown> {
+    /** Raw text deltas — the JSON string as it streams in. */
+    textStream: AsyncIterable<string>;
+    /**
+     * Async iterable of best-effort parsed partial objects. Emits whenever the
+     * accumulated JSON parses cleanly under the partial-JSON repair rules.
+     * Subsequent values are *replacements*, not patches — each is a snapshot.
+     */
+    partialObjectStream: AsyncIterable<T>;
+    /** Resolves to the final parsed object once the stream ends. Rejects if the final JSON is invalid. */
+    object: Promise<T>;
+    /** Resolves to the raw JSON string the model produced. */
+    text: Promise<string>;
+    usage: Promise<TokenUsage>;
+    finishReason: Promise<FinishReason>;
+    /**
+     * Resolves to tool calls the model made during this turn.
+     * Empty for `client.ai.streamObject` (no tools exposed on raw inference);
+     * populated for `client.agents.runObject` when the agent has tools.
+     */
+    toolCalls: Promise<ToolCallRecord[]>;
+}
+interface GenerateObjectResult<T = unknown> {
+    object: T;
+    usage: TokenUsage;
+    finishReason: FinishReason;
+    toolCalls: ToolCallRecord[];
+}
+/**
+ * Build the JSON body for the inference proxy. Public so tests can assert it.
+ * Accepts an optional `responseFormat` so the same builder serves both
+ * `streamText` and `streamObject`.
+ */
+declare function buildInferenceRequestBody(params: StreamTextParams, responseFormat?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Build the `response_format` payload for a JSON-Schema-constrained call.
+ * Emits Fireworks' canonical shape (also accepted by OpenAI):
+ *
+ *   { type: "json_schema",
+ *     json_schema: { name, schema, description?, strict? } }
+ *
+ * @see https://docs.fireworks.ai/structured-responses/structured-response-formatting
+ */
+declare function buildResponseFormat(params: {
+    schema: JsonSchema;
+    name?: string;
+    description?: string;
+    /** Default `true` — providers ignore unknown fields safely. */
+    strict?: boolean;
+}): 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 InferenceRequestContext {
+    /** Resolved URL of the inference endpoint. */
+    url: string;
+    /** Pre-built request headers (`Content-Type` already set). */
+    headers: Headers;
+    /** Bound fetch (already wraps user `fetch` option). */
+    fetch: typeof fetch;
+}
+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>;
+    /**
+     * Stream a JSON-Schema-constrained response. Matches Vercel AI SDK's
+     * `streamObject` shape — returns a synchronous result with `partialObjectStream`
+     * (best-effort incremental parses) and `object` (the final parsed JSON).
+     *
+     * ```ts
+     * const { partialObjectStream, object } = client.ai.streamObject({
+     *   model: "accounts/fireworks/models/kimi-k2p5",
+     *   schema: {
+     *     type: "object",
+     *     properties: {
+     *       title: { type: "string" },
+     *       tags: { type: "array", items: { type: "string" } },
+     *     },
+     *     required: ["title", "tags"],
+     *   },
+     *   messages: [{ role: "user", content: "Give me a blog post idea about AI." }],
+     * });
+     * for await (const partial of partialObjectStream) renderPreview(partial);
+     * const final = await object;
+     * ```
+     */
+    streamObject<T = unknown>(params: StreamObjectParams): StreamObjectResult<T>;
+    /**
+     * Non-streaming variant of {@link streamObject}. Resolves once the model
+     * finishes; rejects if the final text isn't valid JSON for the schema.
+     */
+    generateObject<T = unknown>(params: StreamObjectParams): Promise<GenerateObjectResult<T>>;
+}
+/**
+ * Open a JSON-mode inference stream against the proxy and return a
+ * `StreamObjectResult`. Exposed for advanced callers; most code should use
+ * `RagableBrowserAiClient.streamObject`.
+ */
+declare function streamObjectFromContext<T = unknown>(ctx: InferenceRequestContext, params: StreamObjectParams): StreamObjectResult<T>;
+/**
+ * Wrap a `StreamTextResult` (text-only stream) into a `StreamObjectResult`
+ * by parsing the accumulated text as JSON. The text path stays the source of
+ * truth for `text`/`usage`/`finishReason`/`toolCalls`; this helper only adds
+ * `partialObjectStream` and `object` on top.
+ *
+ * Public so `client.agents.runObject` can reuse the parsing logic — agents
+ * stream text through their own SSE protocol, but the structured-output
+ * conversion is identical.
+ */
+declare function wrapStreamTextAsObject<T = unknown>(inner: StreamTextResult): StreamObjectResult<T>;
+
 /** Canonical browser/server API base (`…/api`, no trailing slash). */
 declare function normalizeBrowserApiBase(): string;
 type BrowserDataAuthMode = "user" | "publicAnon" | "admin";
@@ -1674,10 +1822,79 @@ 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;
+    /**
+     * Same agent, same tools/instructions/RAG — but constrain the final output
+     * to a JSON Schema. Matches `client.ai.streamObject` exactly so callers can
+     * swap between raw inference and an agent without changing call shape.
+     *
+     * Tool calling and structured output are **compatible**: the model may call
+     * the agent's tools as usual; the final assistant message is the schema-
+     * conformant JSON. The agent's `agents/<name>.json` is unchanged — whether
+     * the run is conversational or structured is decided by the call site.
+     *
+     * ```ts
+     * const { partialObjectStream, object } = client.agents.runObject<Plan>(
+     *   "planner",
+     *   {
+     *     messages: [{ role: "user", content: "Plan a 3-day trip to Kyoto." }],
+     *     schema: {
+     *       type: "object",
+     *       properties: {
+     *         days: {
+     *           type: "array",
+     *           items: { type: "object", properties: { date: { type: "string" }, activities: { type: "array", items: { type: "string" } } } },
+     *         },
+     *       },
+     *       required: ["days"],
+     *     },
+     *   },
+     * );
+     * for await (const p of partialObjectStream) renderPreview(p);
+     * console.log(await object);
+     * ```
+     */
+    runObject<T = unknown>(agentName: string, params: {
+        messages: Message[];
+        schema: JsonSchema;
+        schemaName?: string;
+        schemaDescription?: string;
+        signal?: AbortSignal;
+    }): StreamObjectResult<T>;
+    /** Non-streaming variant of {@link runObject}. */
+    generateObject<T = unknown>(agentName: string, params: {
+        messages: Message[];
+        schema: JsonSchema;
+        schemaName?: string;
+        schemaDescription?: string;
+        signal?: AbortSignal;
+    }): Promise<GenerateObjectResult<T>>;
+    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 +1928,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 +1955,22 @@ 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}.
+ * Best-effort parser for incomplete JSON streamed token-by-token from an LLM.
  *
- * @example
- * const bucket = ragable.storage.from("bucket-id");
+ * Used by `streamObject` to emit partial objects as the model writes them.
+ * Strategy:
+ *   1. Try `JSON.parse(text)` — if it works, the JSON is already complete.
+ *   2. Otherwise scan the text and close any open `{`, `[`, or string literal
+ *      so the result is parseable.
+ *   3. If a trailing comma is the problem, strip it and retry.
  *
- * // Upload a file
- * await bucket.upload({ objectPath: "data/report.pdf", file: pdfBlob });
+ * Returns `undefined` when no parseable prefix can be recovered.
  *
- * // 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" });
+ * Designed to be allocation-light and dep-free.
  */
-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 function tryParsePartialJson(text: string): unknown | undefined;
 
-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 GenerateObjectResult, type GenerateTextResult, type HttpMethod, type Json, type JsonSchema, 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 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 };