@ragable/sdk 0.6.21 → 0.6.23

package/dist/index.d.mts

@@ -234,6 +234,249 @@ declare class ShiftClient {
     }>;
 }
 
+/**
+ * First SSE frame for website project agents (`POST …/agents/:name/chat/stream`).
+ */
+interface AgentStreamAgentInfoEvent {
+    type: "agent:info";
+    name: string;
+    agent_name: string;
+}
+/** Payload on the terminal `done` event (matches backend {@link AgentChatResult} + usage fields). */
+interface AgentChatStreamDonePayload {
+    response: string;
+    traces: unknown[];
+    totalDurationMs: number;
+    httpResponse?: unknown;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedPromptTokens?: number;
+    cacheCreationInputTokens?: number;
+    completionProviders?: string[];
+    creditsCharged?: number;
+    agentSteps?: number;
+    finishReason?: string | null;
+    stopReason?: string | null;
+    turnMessages?: unknown;
+    promptTokensEstimated?: number;
+    contextWindow?: number;
+}
+/**
+ * Resolved outcome after the stream finishes. `assistantText` is the concatenation of
+ * all `token` deltas; `response` is the server’s final string from `done` (authoritative).
+ */
+interface AgentChatStreamResult extends AgentChatStreamDonePayload {
+    assistantText: string;
+    reasoningText: string;
+}
+interface AgentChatStreamHandlers {
+    /** Every parsed SSE object (including `ping`, `node:*`, etc.). */
+    onEvent?: (event: AgentStreamEvent) => void;
+    onAgentInfo?: (info: AgentStreamAgentInfoEvent) => void;
+    onToken?: (token: string, ctx: {
+        nodeId: string;
+    }) => void;
+    onReasoningToken?: (token: string, ctx: {
+        nodeId: string;
+    }) => void;
+    onToolCall?: (ctx: {
+        nodeId: string;
+        toolName: string;
+        args: unknown;
+    }) => void;
+    onToolArgsUpdate?: (ctx: {
+        nodeId: string;
+        args: Record<string, unknown>;
+    }) => void;
+    onToolResult?: (ctx: {
+        nodeId: string;
+        toolName: string;
+        durationMs: number;
+        result?: string;
+    }) => void;
+    onNodeStart?: (ctx: {
+        nodeId: string;
+        nodeType: string;
+        label: string;
+    }) => void;
+    onNodeComplete?: (ctx: {
+        nodeId: string;
+        output: unknown;
+        durationMs: number;
+    }) => void;
+    onNodeError?: (ctx: {
+        nodeId: string;
+        error: string;
+    }) => void;
+    /** Backend heartbeat — safe to ignore in UI. */
+    onPing?: () => void;
+    /** Fired when the server emits `done` (before {@link onComplete}). */
+    onDone?: (payload: AgentChatStreamDonePayload) => void;
+    /**
+     * Always called on successful completion (after `done`). Not called if the stream
+     * errors or ends without `done`.
+     */
+    onComplete?: (result: AgentChatStreamResult) => void;
+    onError?: (error: unknown) => void;
+}
+interface RunAgentChatStreamOptions {
+    /**
+     * Abort while consuming events (in addition to any `signal` on the HTTP request).
+     * Stops reading and throws {@link RagableAbortError}.
+     */
+    signal?: AbortSignal;
+}
+/** Narrow `done` events from a loose {@link AgentStreamEvent}. */
+declare function parseAgentStreamDone(e: AgentStreamEvent): AgentChatStreamDonePayload | null;
+/** @public Parse the initial `agent:info` SSE frame (website project agents). */
+declare function parseAgentStreamAgentInfo(e: AgentStreamEvent): AgentStreamAgentInfoEvent | null;
+/**
+ * Consume a Ragable agent SSE stream with callbacks and return the final result.
+ *
+ * For the same segment model as dashboard `AgentChat` (`streamingSegments` /
+ * `streamingContent`), use {@link runAgentChatStreamForUi} or
+ * `client.agents.runChatUiByName` instead.
+ *
+ * Typical low-level chat (string accumulation only):
+ *
+ * ```ts
+ * const result = await client.agents.runChatStreamByName("support", {
+ *   message: input,
+ *   history,
+ *   signal: ac.signal,
+ * }, {
+ *   onToken: (t) => setReply((s) => s + t),
+ * });
+ * ```
+ *
+ * Lower-level (same client, manual iterator):
+ *
+ * ```ts
+ * const result = await runAgentChatStream(
+ *   client.agents.chatStreamByName("support", { message, signal }),
+ *   { onToken: (t) => append(t) },
+ *   { signal },
+ * );
+ * ```
+ */
+declare function runAgentChatStream(source: AsyncIterable<AgentStreamEvent>, handlers?: AgentChatStreamHandlers, options?: RunAgentChatStreamOptions): Promise<AgentChatStreamResult>;
+/**
+ * Like {@link runAgentChatStream} but resolves with `null` if the stream ends without `done`
+ * instead of throwing. Errors other than incomplete stream are still thrown.
+ */
+declare function runAgentChatStreamLenient(source: AsyncIterable<AgentStreamEvent>, handlers?: AgentChatStreamHandlers, options?: RunAgentChatStreamOptions): Promise<AgentChatStreamResult | null>;
+/** True when {@link runAgentChatStream} stopped because no `done` event arrived. */
+declare function isIncompleteAgentStreamError(e: unknown): boolean;
+
+/**
+ * UI-oriented agent streaming — folds wire events into the same segment model as
+ * `app/web/src/components/AgentChat.tsx` (`StreamSegment`), matching the reducers in
+ * `useEngineIDEAgent` / `useIDEAgent` (tool gating, coalesced text/reasoning, etc.).
+ */
+
+/**
+ * Chat UI segments — structural parity with `StreamSegment` in dashboard `AgentChat`.
+ */
+type AgentChatUiSegment = {
+    type: "text";
+    content: string;
+} | {
+    type: "reasoning";
+    content: string;
+} | {
+    type: "tool";
+    id: string;
+    toolName: string;
+    status: "started" | "completed";
+    durationMs?: number;
+    args?: Record<string, unknown>;
+    result?: string;
+} | {
+    type: "context_summarized";
+    step: number;
+    mode?: "llm" | "heuristic" | "llm+heuristic" | "aggressive";
+    reason?: "soft_limit" | "forced";
+    tokensRemovedEstimate?: number;
+    estimatedTokensAfter?: number;
+} | {
+    type: "llm_step";
+    step: number;
+    inputTokens: number;
+    outputTokens: number;
+    cachedPromptTokens?: number;
+    cacheCreationInputTokens?: number;
+    creditsEstimated: number;
+    apiCostUsd?: number;
+    provider?: string;
+} | {
+    type: "stop_reason";
+    content: string;
+    finishReason: string;
+};
+/** Assistant row to append to chat history (add your own `id`). */
+interface AgentChatUiAssistantMessage {
+    role: "ai";
+    content: string;
+    segments?: AgentChatUiSegment[];
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        creditsCharged: number;
+        cachedPromptTokens?: number;
+        cacheCreationInputTokens?: number;
+    };
+    durationMs?: number;
+    finishReason?: string | null;
+    completionProviders?: string[];
+    agentSteps?: number;
+}
+interface AgentChatUiStreamResult {
+    /** Segments immediately before `done` (no trailing `stop_reason`). */
+    segmentsMidTurn: AgentChatUiSegment[];
+    /** Final segments including optional `stop_reason` from `done`. */
+    segments: AgentChatUiSegment[];
+    /** Persisted assistant message — matches dashboard `ChatMessageData` for `ai` (except `id`). */
+    message: AgentChatUiAssistantMessage;
+    done: AgentChatStreamDonePayload;
+}
+interface AgentChatStreamUiHandlers {
+    /**
+     * Live segment list — pass to `AgentChat` as `streamingSegments` (or your own renderer).
+     */
+    onSegments?: (segments: AgentChatUiSegment[]) => void;
+    /**
+     * Plain assistant text — mirrors dashboard `streamingContent` (text channel only).
+     */
+    onStreamingText?: (text: string) => void;
+    onAgentInfo?: (info: AgentStreamAgentInfoEvent) => void;
+    onEvent?: (event: AgentStreamEvent) => void;
+    onDone?: (payload: AgentChatStreamDonePayload) => void;
+    onComplete?: (result: AgentChatUiStreamResult) => void;
+    onError?: (error: unknown) => void;
+}
+/** Concatenate `text` segments (ignores reasoning/tools). */
+declare function collectAssistantTextFromUiSegments(segments: AgentChatUiSegment[]): string;
+/**
+ * Pure fold: one SSE event → next segment list. Matches `useEngineIDEAgent` / `useIDEAgent`
+ * behavior for token gating while a tool is in the `started` state.
+ */
+declare function foldAgentStreamIntoUiSegments(prev: AgentChatUiSegment[], event: AgentStreamEvent): AgentChatUiSegment[];
+/**
+ * Merge live segments with the terminal `done` payload (optional `stop_reason` segment),
+ * and build the persisted assistant message — same shape as dashboard `ChatMessageData` for `ai`.
+ */
+declare function finalizeAgentChatUiTurn(segments: AgentChatUiSegment[], done: AgentChatStreamDonePayload): {
+    segments: AgentChatUiSegment[];
+    message: AgentChatUiAssistantMessage;
+};
+/**
+ * Consume a stream and drive dashboard-style UI state: {@link AgentChatStreamUiHandlers.onSegments}
+ * / {@link AgentChatStreamUiHandlers.onStreamingText} mirror `AgentChat`’s `streamingSegments` /
+ * `streamingContent`; the returned {@link AgentChatUiStreamResult.message} is ready to append
+ * to history like `useEngineIDEAgent` does on `done`.
+ */
+declare function runAgentChatStreamForUi(source: AsyncIterable<AgentStreamEvent>, handlers?: AgentChatStreamUiHandlers, options?: RunAgentChatStreamOptions): Promise<AgentChatUiStreamResult>;
+
 interface AgentSummary {
     id: string;
     name: string;
@@ -249,6 +492,8 @@ interface AgentChatMessage {
 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 {
@@ -275,6 +520,16 @@ declare class AgentsClient {
      * 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. */
@@ -856,6 +1111,7 @@ type BrowserDataAuthMode = "user" | "publicAnon" | "admin";
 declare function effectiveDataAuth(options: RagableBrowserClientOptions): BrowserDataAuthMode;
 interface RagableBrowserClientOptions {
     organizationId: string;
+    websiteId?: string;
     authGroupId?: string;
     databaseInstanceId?: string;
     /** When omitted, inferred from static keys — see {@link effectiveDataAuth}. */
@@ -1109,6 +1365,11 @@ declare class BrowserCollectionApi<Row extends Record<string, unknown> = Record<
         } & Partial<WhereInput<RowD<Row>>>;
     }) => Promise<PostgrestResult<BrowserCollectionRecord<RowD<Row>> | null>>;
     insert: (data: BrowserCollectionInsertData<Row, Insert>) => Promise<PostgrestResult<BrowserCollectionRecord<RowD<Row>>>>;
+    /**
+     * Insert multiple rows in one request (server multi-value `INSERT`, single transaction).
+     * Empty **`items`** resolves to an empty array. Max batch size is enforced on the server (500).
+     */
+    insertMany: (items: BrowserCollectionInsertData<Row, Insert>[]) => Promise<PostgrestResult<BrowserCollectionRecord<RowD<Row>>[]>>;
     /**
      * Update rows matching `where` (JSON fields, plus envelope `id` / `createdAt` / `updatedAt`).
      */
@@ -1133,6 +1394,18 @@ declare class BrowserCollectionApi<Row extends Record<string, unknown> = Record<
         deleted: number;
         records: BrowserCollectionRecord<RowD<Row>>[];
     }>>;
+    /**
+     * Like {@link BrowserCollectionApi.delete} but the success payload includes **`meta.count`**
+     * (number of deleted rows), matching {@link BrowserCollectionApi.updateMany}.
+     */
+    deleteMany: (where: WhereInput<RowD<Row>>, options?: {
+        limit?: number;
+    }) => Promise<PostgrestResult<{
+        records: BrowserCollectionRecord<RowD<Row>>[];
+        meta: {
+            count: number;
+        };
+    }>>;
 }
 type BrowserCollections<Database extends RagableDatabase = DefaultRagableDatabase> = [keyof Database["public"]["Tables"]] extends [never] ? Record<string, BrowserCollectionApi<Record<string, unknown>>> : {
     readonly [Name in RagableTableNames<Database>]: BrowserCollectionApi<TableRow<Database, Name>, TableInsertRow<Database, Name>, TableUpdatePatch<Database, Name>>;
@@ -1247,12 +1520,64 @@ interface BrowserRealtimeSubscription {
     unsubscribe: () => void;
     readonly status: BrowserRealtimeStatus;
 }
+interface AgentConversationMessage {
+    role: "user" | "assistant";
+    content: string;
+    file_urls?: string[];
+}
+interface AgentConversation {
+    id: string;
+    agent_name: string;
+    agentName: string;
+    title: string | null;
+    metadata: unknown;
+    messages: AgentConversationMessage[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface AgentConversationSubscription {
+    unsubscribe: () => void;
+}
 declare class RagableBrowserAgentsClient {
     private readonly options;
     private readonly fetchImpl;
     constructor(options: RagableBrowserClientOptions);
     private toUrl;
+    private requireWebsiteId;
+    private websiteAgentPath;
+    private requestJson;
+    /** @deprecated Prefer `chatStreamByName(agentName, params)` for project-local `/agents/*.json` agents. */
     chatStream(agentId: string, params: AgentPublicChatParams): AsyncGenerator<AgentStreamEvent, void, undefined>;
+    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.
+     */
+    runChatStreamByName(agentName: string, params: AgentChatParams, handlers?: AgentChatStreamHandlers): Promise<AgentChatStreamResult>;
+    /**
+     * Same as {@link runChatStreamByName} but folds events into `AgentChat`-style segments
+     * (`onSegments` / `onStreamingText`) and returns a history-ready assistant message.
+     */
+    runChatUiByName(agentName: string, params: AgentChatParams, handlers?: AgentChatStreamUiHandlers): Promise<AgentChatUiStreamResult>;
+    createConversation(params: {
+        agent_name?: string;
+        agentName?: string;
+        title?: string | null;
+        metadata?: unknown;
+    }): Promise<AgentConversation>;
+    listConversations(params?: {
+        agent_name?: string;
+        agentName?: string;
+    }): Promise<AgentConversation[]>;
+    getConversation(conversationId: string): Promise<AgentConversation>;
+    updateConversation(conversationId: string, data: {
+        title?: string | null;
+        metadata?: unknown;
+    }): Promise<AgentConversation>;
+    addMessage(conversationOrId: AgentConversation | string, message: AgentConversationMessage): Promise<AgentConversation>;
+    subscribeToConversation(conversationId: string, callback: (conversation: AgentConversation) => void, options?: {
+        intervalMs?: number;
+    }): AgentConversationSubscription;
 }
 interface AgentPublicChatParams extends AgentChatParams {
     triggerSubtype?: string;
@@ -1348,4 +1673,4 @@ 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 AgentPublicChatParams, 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 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 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, collectionRecordToRowWithMeta, collectionRecordsToRowWithMeta, createBrowserClient, createClient, createRagPipeline, createRagableBrowserClient, createRagableServerClient, detectStorage, effectiveDataAuth, extractErrorMessage, formatPostgrestError, formatRetrievalContext, formatSdkError, generateIdempotencyKey, normalizeBrowserApiBase, parseSseDataLine, parseTransportResponse, readSseStream, toRagableResult, unwrapPostgrest };
+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 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 };