@iota-uz/sdk 0.20.0 → 0.22.0

package/dist/chat-ui/components/WelcomeContent.d.ts

@@ -0,0 +1,17 @@
+import { type JSX } from "solid-js";
+import { type IconComponent } from '../icons';
+interface WelcomeContentProps {
+    onPromptSelect?: (prompt: string) => void;
+    title?: string;
+    description?: string;
+    disabled?: boolean;
+    /** Custom prompts to replace the default i18n prompts. Icons cycle from defaults if not provided. */
+    prompts?: Array<{
+        category: string;
+        text: string;
+        icon?: IconComponent;
+    }>;
+}
+declare function WelcomeContent(solidProps1Input: WelcomeContentProps): JSX.Element;
+export { WelcomeContent };
+export default WelcomeContent;

package/dist/chat-ui/config/ConfigContext.d.ts

@@ -0,0 +1,61 @@
+import { type JSX } from "solid-js";
+/**
+ * Configuration context provider for BiChat.
+ *
+ * @deprecated Use `IotaContextProvider` with its new optional `context` prop
+ * instead. `ConfigProvider` and `BiChatConfig` are kept for backwards
+ * compatibility but will be removed in a future major version.
+ */
+/** @deprecated Use `IotaContextProvider` with its `context` prop instead. */
+export interface BiChatConfig {
+    user: {
+        id: string;
+        email: string;
+        firstName: string;
+        lastName: string;
+        permissions: string[];
+    };
+    tenant: {
+        id: string;
+        name: string;
+    };
+    locale: {
+        language: string;
+        translations: Record<string, string>;
+    };
+    endpoints: {
+        rpc: string;
+        stream: string;
+    };
+    csrfToken?: string;
+}
+interface ConfigProviderProps {
+    config?: BiChatConfig;
+    useGlobalConfig?: boolean;
+    children: JSX.Element;
+}
+/**
+ * @deprecated Use `IotaContextProvider` with its `context` prop instead.
+ *
+ * ConfigProvider component — provides configuration to the BiChat library.
+ *
+ * @param config - Configuration object (preferred method)
+ * @param useGlobalConfig - If true, falls back to window.__APPLET_CONTEXT__ when config is not provided
+ * @param children - React children
+ */
+export declare function ConfigProvider(solidProps1Input: ConfigProviderProps): JSX.Element;
+/**
+ * Hook to access BiChat configuration
+ * Returns null if no configuration is available
+ */
+export declare function useConfig(): BiChatConfig | null;
+/**
+ * Hook to access BiChat configuration (required)
+ * Throws an error if configuration is not available
+ */
+export declare function useRequiredConfig(): BiChatConfig;
+/**
+ * Check if user has a specific permission
+ */
+export declare function hasPermission(config: BiChatConfig | null, permission: string): boolean;
+export {};

package/dist/chat-ui/context/ChatContext.d.ts

@@ -0,0 +1,42 @@
+import { type JSX } from "solid-js";
+/**
+ * Chat session context provider and hooks.
+ *
+ * Thin React wrapper around ChatMachine. All async logic (session fetch,
+ * streaming, HITL, slash commands, queue, rate limiting) lives in the
+ * framework-agnostic ChatMachine class.
+ *
+ * Split into 3 focused contexts to minimize re-renders:
+ * - ChatSessionContext: session lifecycle (session, fetching, error, debug)
+ * - ChatMessagingContext: turns + streaming + tool interactions
+ * - ChatInputContext: input form state (message, inputError, queue)
+ */
+import type { ChatDataSource, ChatSessionStateValue, ChatMessagingStateValue, ChatInputStateValue } from '../types';
+import { RateLimiter, type RateLimiterConfig } from '../utils/RateLimiter';
+export interface ChatSessionProviderProps {
+    dataSource: ChatDataSource;
+    sessionId?: string;
+    /**
+     * External rate limiter instance. Captured once at mount — changing this prop
+     * after initial render has no effect. For most cases, use `rateLimitConfig`
+     * instead and let the provider create the limiter internally.
+     */
+    rateLimiter?: RateLimiter;
+    /**
+     * Configuration for the built-in rate limiter (ignored when `rateLimiter` is
+     * provided). Captured once at mount — changing after initial render has no effect.
+     */
+    rateLimitConfig?: RateLimiterConfig;
+    /**
+     * Called when the machine creates a new session (e.g. on first message in a
+     * "new chat"). Use this to navigate your SPA router to the new session URL.
+     */
+    onSessionCreated?: (sessionId: string) => void;
+    children: JSX.Element;
+}
+export declare function ChatSessionProvider(solidProps1: ChatSessionProviderProps): JSX.Element;
+export declare function useChatSession(): ChatSessionStateValue;
+export declare function useChatMessaging(): ChatMessagingStateValue;
+/** Returns messaging context or null when outside ChatSessionProvider. */
+export declare function useOptionalChatMessaging(): ChatMessagingStateValue | null;
+export declare function useChatInput(): ChatInputStateValue;

package/dist/chat-ui/context/IotaContext.d.ts

@@ -0,0 +1,21 @@
+import { type JSX } from "solid-js";
+/**
+ * IOTA SDK integration context provider
+ * Consumes server-side context from window.__APPLET_CONTEXT__ or accepts it as a prop.
+ */
+import type { IotaContext as IotaContextType } from '../types/iota';
+interface IotaContextProviderProps {
+    /**
+     * Explicit context object. When provided, the window global is not read.
+     * Useful for tests, Storybook, or apps that manage their own context.
+     */
+    context?: IotaContextType;
+    children: JSX.Element;
+}
+export declare function IotaContextProvider(solidProps1: IotaContextProviderProps): JSX.Element;
+export declare function useIotaContext(): IotaContextType;
+/**
+ * Check if user has a specific permission
+ */
+export declare function hasPermission(permission: string): boolean;
+export {};

package/dist/chat-ui/context/chatHelpers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pure helper functions for the ChatContext provider.
+ * Extracted to keep the main provider file focused on state and handlers.
+ */
+import { type ConversationTurn, type Attachment, type DebugLimits } from '../types';
+/** Tool names that produce persisted artifacts; must match server ArtifactHandler. */
+export declare const ARTIFACT_TOOL_NAMES: Set<string>;
+export declare function generateTempId(prefix: string): string;
+export declare function createPendingTurn(sessionId: string, content: string, attachments?: Attachment[]): ConversationTurn;
+export declare function createCompactedSystemTurn(sessionId: string, summary: string): ConversationTurn;
+export type SlashCommandName = '/clear' | '/debug' | '/compact';
+export interface ParsedSlashCommand {
+    name: SlashCommandName;
+    hasArgs: boolean;
+}
+export declare function parseSlashCommand(input: string): ParsedSlashCommand | null;
+export declare function readDebugLimitsFromGlobalContext(): DebugLimits | null;
+export declare function readReasoningEffortOptionsFromGlobalContext(): string[] | undefined;

package/dist/chat-ui/context/externalSnapshot.d.ts

@@ -0,0 +1,4 @@
+import { type Accessor } from 'solid-js';
+export declare function createExternalSnapshot<T>(subscribe: (listener: () => void) => () => void, snapshot: () => T): Accessor<T>;
+export declare function createReactiveSnapshot<T extends object>(subscribe: (listener: () => void) => () => void, snapshot: () => T): T;
+export declare function createReactiveValue<T extends object>(value: Accessor<T>): T;

package/dist/chat-ui/data/ArtifactManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Session artifact CRUD: fetch, upload, rename, delete artifacts.
+ *
+ * @internal — Not part of the public API. Consumed by HttpDataSource.
+ */
+import type { BichatRPC } from './rpc.generated';
+import type { SessionArtifact } from '../types';
+import type { CoreUploadResponse } from './AttachmentUploader';
+type RPCCaller = <TMethod extends keyof BichatRPC & string>(method: TMethod, params: BichatRPC[TMethod]['params']) => Promise<BichatRPC[TMethod]['result']>;
+export declare function fetchSessionArtifacts(callRPC: RPCCaller, sessionId: string, options?: {
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    artifacts: SessionArtifact[];
+    hasMore?: boolean;
+    nextOffset?: number;
+}>;
+export declare function uploadSessionArtifacts(callRPC: RPCCaller, sessionId: string, files: File[], uploadFileFn: (file: File) => Promise<CoreUploadResponse>): Promise<{
+    artifacts: SessionArtifact[];
+}>;
+export declare function renameSessionArtifact(callRPC: RPCCaller, artifactId: string, name: string, description?: string): Promise<SessionArtifact>;
+export declare function deleteSessionArtifact(callRPC: RPCCaller, artifactId: string): Promise<void>;
+export {};

package/dist/chat-ui/data/AttachmentUploader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Attachment file processing and upload logic.
+ *
+ * Handles MIME detection from file signatures, filename normalization,
+ * base64/URL decoding, and upload to the core upload endpoint.
+ *
+ * @internal — Not part of the public API. Consumed by HttpDataSource.
+ */
+import type { Attachment } from '../types';
+export interface CoreUploadResponse {
+    id: number;
+    url: string;
+    path: string;
+    name: string;
+    mimetype: string;
+    size: number;
+}
+export declare function uploadFile(file: File, baseUrl: string, uploadEndpoint: string, createUploadHeaders: () => Headers, fetcher?: typeof fetch): Promise<CoreUploadResponse>;
+export declare function assertUploadReferences(uploads: CoreUploadResponse[]): Array<{
+    uploadId: number;
+}>;
+export declare function ensureAttachmentUpload(attachment: Attachment, context: {
+    sessionId: string;
+    attachmentIndex: number;
+}, uploadFileFn: (file: File) => Promise<CoreUploadResponse>): Promise<CoreUploadResponse>;

package/dist/chat-ui/data/HttpDataSource.d.ts

@@ -0,0 +1,109 @@
+import type { ChatDataSource, Session, SessionMember, SessionListResult, SessionUser, SessionArtifact, Attachment, StreamChunk, StreamStatus, QuestionAnswers, SendMessageOptions, AsyncRunAccepted } from '../types';
+import type { SessionState } from './SessionManager';
+import * as Messages from './MessageTransport';
+export interface HttpDataSourceConfig {
+    baseUrl: string;
+    rpcEndpoint: string;
+    streamEndpoint?: string;
+    uploadEndpoint?: string;
+    csrfToken?: string | (() => string);
+    headers?: Record<string, string>;
+    rpcTimeoutMs?: number;
+    /** Optional transport owned by the mounted host. */
+    fetcher?: typeof fetch;
+    streamConnectTimeoutMs?: number;
+}
+export declare class HttpDataSource implements ChatDataSource {
+    private config;
+    private abortController;
+    private rpc;
+    constructor(config: HttpDataSourceConfig);
+    private getCSRFToken;
+    private createHeaders;
+    private createUploadHeaders;
+    private callRPC;
+    private boundCallRPC;
+    private boundUploadFile;
+    createSession(): Promise<Session>;
+    fetchSession(id: string): Promise<SessionState | null>;
+    listSessions(options?: {
+        limit?: number;
+        offset?: number;
+        includeArchived?: boolean;
+    }): Promise<SessionListResult>;
+    archiveSession(sessionId: string): Promise<Session>;
+    unarchiveSession(sessionId: string): Promise<Session>;
+    pinSession(sessionId: string): Promise<Session>;
+    unpinSession(sessionId: string): Promise<Session>;
+    deleteSession(sessionId: string): Promise<void>;
+    renameSession(sessionId: string, title: string): Promise<Session>;
+    regenerateSessionTitle(sessionId: string): Promise<Session>;
+    clearSessionHistory(sessionId: string): Promise<{
+        success: boolean;
+        deletedMessages: number;
+        deletedArtifacts: number;
+    }>;
+    compactSessionHistory(sessionId: string): Promise<AsyncRunAccepted>;
+    listUsers(): Promise<SessionUser[]>;
+    listAllSessions(options?: {
+        limit?: number;
+        offset?: number;
+        includeArchived?: boolean;
+        userId?: string | null;
+    }): Promise<{
+        sessions: Session[];
+        total: number;
+        hasMore: boolean;
+    }>;
+    listSessionMembers(sessionId: string): Promise<SessionMember[]>;
+    addSessionMember(sessionId: string, userId: string, role: 'editor' | 'viewer'): Promise<void>;
+    updateSessionMemberRole(sessionId: string, userId: string, role: 'editor' | 'viewer'): Promise<void>;
+    removeSessionMember(sessionId: string, userId: string): Promise<void>;
+    stopGeneration(sessionId: string): Promise<void>;
+    getStreamStatus(sessionId: string): Promise<StreamStatus | null>;
+    resumeStream(sessionId: string, runId: string, onChunk: (chunk: StreamChunk) => void, signal?: AbortSignal): Promise<void>;
+    /**
+     * Open a native EventSource against GET /stream/events for the given
+     * run. Used by components that want browser-native auto-reconnect
+     * with Last-Event-ID (tab close, wifi drop, device switch). Prefer
+     * over resumeStream when tailing an already-running generation that
+     * another tab started.
+     */
+    subscribeRunEvents(sessionId: string, runId: string, options: Messages.SubscribeRunEventsOptions): Promise<void>;
+    /**
+     * Subscribe to the per-tenant active-run fan-out
+     * (GET /stream/active-runs). Never resolves until the caller aborts
+     * via the signal; use from a top-level component (sidebar container)
+     * that mounts for the lifetime of the chat app.
+     */
+    subscribeActiveRuns(options: Messages.SubscribeActiveRunsOptions): Promise<void>;
+    sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal, options?: SendMessageOptions): AsyncGenerator<StreamChunk>;
+    cancelStream(): void;
+    submitQuestionAnswers(sessionId: string, questionId: string, answers: QuestionAnswers): Promise<{
+        success: boolean;
+        data?: AsyncRunAccepted;
+        error?: string;
+    }>;
+    rejectPendingQuestion(sessionId: string): Promise<{
+        success: boolean;
+        data?: AsyncRunAccepted;
+        error?: string;
+    }>;
+    fetchSessionArtifacts(sessionId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        artifacts: SessionArtifact[];
+        hasMore?: boolean;
+        nextOffset?: number;
+    }>;
+    uploadSessionArtifacts(sessionId: string, files: File[]): Promise<{
+        artifacts: SessionArtifact[];
+    }>;
+    renameSessionArtifact(artifactId: string, name: string, description?: string): Promise<SessionArtifact>;
+    deleteSessionArtifact(artifactId: string): Promise<void>;
+}
+/**
+ * Factory function to create HttpDataSource
+ */
+export declare function createHttpDataSource(config: HttpDataSourceConfig): ChatDataSource;

package/dist/chat-ui/data/ManagedHttpDataSource.d.ts

@@ -0,0 +1,26 @@
+import { HttpDataSource, type HttpDataSourceConfig } from './HttpDataSource';
+import type { Attachment, StreamChunk } from '../types';
+import { type SessionService } from '@iota-uz/sdk/client-host';
+interface SendMessageOptions {
+    requestId?: string;
+    debugMode?: boolean;
+    replaceFromMessageID?: string;
+    reasoningEffort?: string;
+    model?: string;
+}
+export declare class ManagedHttpDataSource extends HttpDataSource {
+    private readonly managedConfig;
+    private readonly session;
+    private readonly owner;
+    private readonly subscriptions;
+    constructor(managedConfig: HttpDataSourceConfig, session: SessionService);
+    sendMessage(sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal, options?: SendMessageOptions): AsyncGenerator<StreamChunk>;
+    resumeStream(sessionId: string, runId: string, onChunk: (chunk: StreamChunk) => void, signal?: AbortSignal): Promise<void>;
+    dispose(): void;
+    cancelStream(): void;
+    private openPOSTStream;
+    private openEventStream;
+    private openManagedStream;
+    private uploadReference;
+}
+export {};

package/dist/chat-ui/data/MessageTransport.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Message sending, SSE streaming, and HITL question handling.
+ *
+ * @internal — Not part of the public API. Consumed by HttpDataSource.
+ */
+import type { BichatRPC } from './rpc.generated';
+import type { ActiveRunDelivery, Attachment, StreamChunk, StreamStatus, QuestionAnswers, SendMessageOptions, AsyncRunAccepted } from '../types';
+import { type CoreUploadResponse } from './AttachmentUploader';
+/**
+ * Thrown by {@link subscribeRunEvents} when the underlying EventSource
+ * emits `onerror` before the first event arrives within the
+ * initial-connect grace window. Distinguishes boundary failures
+ * (401 / 404 / 503) from transient mid-run flaps, which the browser's
+ * native auto-reconnect continues to handle silently.
+ */
+export declare class RunEventsConnectError extends Error {
+    readonly cause?: Event;
+    constructor(message: string, cause?: Event);
+}
+interface Result<T> {
+    success: boolean;
+    data?: T;
+    error?: string;
+}
+type RPCCaller = <TMethod extends keyof BichatRPC & string>(method: TMethod, params: BichatRPC[TMethod]['params']) => Promise<BichatRPC[TMethod]['result']>;
+type AttachmentLifecycleLogger = (event: 'stream_send_with_upload_ids', details: Record<string, unknown>) => void;
+export interface MessageTransportDeps {
+    callRPC: RPCCaller;
+    baseUrl: string;
+    streamEndpoint: string;
+    rpcTimeoutMs: number;
+    streamConnectTimeoutMs?: number;
+    createHeaders: (additionalHeaders?: Record<string, string>) => Headers;
+    uploadFileFn: (file: File) => Promise<CoreUploadResponse>;
+    logAttachmentLifecycle: AttachmentLifecycleLogger;
+}
+export declare function sendMessage(deps: MessageTransportDeps, sessionId: string, content: string, attachments?: Attachment[], signal?: AbortSignal, options?: SendMessageOptions): AsyncGenerator<StreamChunk>;
+export declare function stopStream(deps: Pick<MessageTransportDeps, 'baseUrl' | 'streamEndpoint' | 'createHeaders'> & {
+    timeoutMs?: number;
+}, sessionId: string): Promise<void>;
+type StreamStatusResumeDeps = Pick<MessageTransportDeps, 'baseUrl' | 'streamEndpoint' | 'createHeaders'> & {
+    timeoutMs?: number;
+    connectTimeoutMs?: number;
+};
+export declare function getStreamStatus(deps: StreamStatusResumeDeps, sessionId: string): Promise<StreamStatus | null>;
+export declare function resumeStream(deps: StreamStatusResumeDeps, sessionId: string, runId: string, onChunk: (chunk: StreamChunk) => void, signal?: AbortSignal): Promise<void>;
+type StreamEventsDeps = Pick<MessageTransportDeps, 'baseUrl' | 'streamEndpoint'>;
+export interface SubscribeRunEventsOptions {
+    /** When set, start from the last seen event id instead of a full replay. */
+    lastEventId?: string;
+    /** Fires for every chunk (content / tool / snapshot / done / error / …). */
+    onChunk: (chunk: StreamChunk) => void;
+    /** Optional hook for raw SSE errors (connection blips, parse failures). */
+    onError?: (event: Event) => void;
+    /** AbortSignal closes the underlying EventSource. */
+    signal?: AbortSignal;
+}
+/**
+ * Open a native EventSource against GET /stream/events for a run. The
+ * browser handles reconnect + Last-Event-ID automatically on transient
+ * network drops; we forward each SSE event onto onChunk and resolve the
+ * returned promise when a terminal event (done / error) arrives or the
+ * caller aborts.
+ *
+ * Kept separate from sendMessage so the applet can connect to a run
+ * that was started by another tab (shared request_id) or that the
+ * current session already had in flight (tab reopen, device switch).
+ */
+export declare function subscribeRunEvents(deps: StreamEventsDeps, sessionId: string, runId: string, options: SubscribeRunEventsOptions): Promise<void>;
+export interface SubscribeActiveRunsOptions {
+    onEvent: (event: ActiveRunDelivery) => void;
+    onError?: (event: Event) => void;
+    signal?: AbortSignal;
+}
+/**
+ * Open an EventSource to the per-tenant active-run feed. Emits one
+ * "snapshot" row per currently-running session on connect then live
+ * "update" deltas as runs transition. Used by the chat list to render
+ * a status dot without polling each session.
+ *
+ * Never resolves on its own — the caller should abort via the signal
+ * when the component unmounts; the returned promise only settles on
+ * signal abort or initial-connect failure.
+ */
+export declare function subscribeActiveRuns(deps: StreamEventsDeps, options: SubscribeActiveRunsOptions): Promise<void>;
+export declare function submitQuestionAnswers(callRPC: RPCCaller, sessionId: string, questionId: string, answers: QuestionAnswers): Promise<Result<AsyncRunAccepted>>;
+export declare function rejectPendingQuestion(callRPC: RPCCaller, sessionId: string): Promise<Result<AsyncRunAccepted>>;
+export {};

package/dist/chat-ui/data/SessionManager.d.ts

@@ -0,0 +1,52 @@
+import type { BichatRPC } from './rpc.generated';
+import type { Session, SessionMember, SessionUser, SessionListResult, SessionArtifact, ConversationTurn, PendingQuestion, AsyncRunAccepted } from '../types';
+export interface SessionState {
+    session: Session;
+    turns: ConversationTurn[];
+    pendingQuestion?: PendingQuestion | null;
+}
+type RPCCaller = <TMethod extends keyof BichatRPC & string>(method: TMethod, params: BichatRPC[TMethod]['params']) => Promise<BichatRPC[TMethod]['result']>;
+type FetchSessionArtifactsFn = (sessionId: string, options?: {
+    limit?: number;
+    offset?: number;
+}) => Promise<{
+    artifacts: SessionArtifact[];
+    hasMore?: boolean;
+    nextOffset?: number;
+}>;
+export declare function createSession(callRPC: RPCCaller): Promise<Session>;
+export declare function fetchSession(id: string, callRPC: RPCCaller, fetchArtifacts: FetchSessionArtifactsFn): Promise<SessionState | null>;
+export declare function listSessions(callRPC: RPCCaller, options?: {
+    limit?: number;
+    offset?: number;
+    includeArchived?: boolean;
+}): Promise<SessionListResult>;
+export declare function archiveSession(callRPC: RPCCaller, sessionId: string): Promise<Session>;
+export declare function unarchiveSession(callRPC: RPCCaller, sessionId: string): Promise<Session>;
+export declare function pinSession(callRPC: RPCCaller, sessionId: string): Promise<Session>;
+export declare function unpinSession(callRPC: RPCCaller, sessionId: string): Promise<Session>;
+export declare function deleteSession(callRPC: RPCCaller, sessionId: string): Promise<void>;
+export declare function renameSession(callRPC: RPCCaller, sessionId: string, title: string): Promise<Session>;
+export declare function regenerateSessionTitle(callRPC: RPCCaller, sessionId: string): Promise<Session>;
+export declare function clearSessionHistory(callRPC: RPCCaller, sessionId: string): Promise<{
+    success: boolean;
+    deletedMessages: number;
+    deletedArtifacts: number;
+}>;
+export declare function compactSessionHistory(callRPC: RPCCaller, sessionId: string): Promise<AsyncRunAccepted>;
+export declare function listUsers(callRPC: RPCCaller): Promise<SessionUser[]>;
+export declare function listAllSessions(callRPC: RPCCaller, options?: {
+    limit?: number;
+    offset?: number;
+    includeArchived?: boolean;
+    userId?: string | null;
+}): Promise<{
+    sessions: Session[];
+    total: number;
+    hasMore: boolean;
+}>;
+export declare function listSessionMembers(callRPC: RPCCaller, sessionId: string): Promise<SessionMember[]>;
+export declare function addSessionMember(callRPC: RPCCaller, sessionId: string, userId: string, role: 'editor' | 'viewer'): Promise<void>;
+export declare function updateSessionMemberRole(callRPC: RPCCaller, sessionId: string, userId: string, role: 'editor' | 'viewer'): Promise<void>;
+export declare function removeSessionMember(callRPC: RPCCaller, sessionId: string, userId: string): Promise<void>;
+export {};

package/dist/chat-ui/data/applet-rpc.d.ts

@@ -0,0 +1,29 @@
+export interface AppletRPCError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+export declare class AppletRPCException extends Error {
+    code: string;
+    details?: unknown;
+    cause?: unknown;
+    constructor(args: {
+        code: string;
+        message: string;
+        details?: unknown;
+        cause?: unknown;
+    });
+}
+export type AppletRPCSchema = Record<string, {
+    params: unknown;
+    result: unknown;
+}>;
+export interface CreateAppletRPCClientOptions {
+    endpoint: string;
+    fetcher?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare function createAppletRPCClient(options: CreateAppletRPCClientOptions): {
+    call: <TParams, TResult>(method: string, params: TParams) => Promise<TResult>;
+    callTyped: <TRouter extends AppletRPCSchema, TMethod extends keyof TRouter & string>(method: TMethod, params: TRouter[TMethod]["params"]) => Promise<TRouter[TMethod]["result"]>;
+};

package/dist/chat-ui/data/mappers.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Type mapping and sanitization functions for converting RPC payloads
+ * to domain types used by the BiChat UI.
+ *
+ * All functions are pure and side-effect-free (except console.warn for
+ * malformed payloads).
+ *
+ * @internal — Not part of the public API. Consumed by HttpDataSource modules.
+ */
+import type { Session as RPCSession } from "./rpc.generated";
+import type { PendingQuestion as RPCPendingQuestion } from "./rpc.generated";
+import type { Session, ConversationTurn, SessionArtifact, PendingQuestion } from "../types";
+export interface RPCArtifact {
+    id: string;
+    sessionId: string;
+    messageId?: string;
+    uploadId?: number | null;
+    type: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+    url?: string;
+    sizeBytes: number;
+    metadata?: Record<string, unknown>;
+    createdAt: string;
+}
+export declare function warnMalformedSessionPayload(message: string, details?: Record<string, unknown>): void;
+export declare function toSession(session: RPCSession): Session;
+export declare function toSessionArtifact(artifact: RPCArtifact): SessionArtifact;
+export declare function sanitizeConversationTurns(rawTurns: unknown, sessionID: string): ConversationTurn[];
+export declare function sanitizePendingQuestion(rawPendingQuestion: RPCPendingQuestion | null | undefined, sessionID: string): PendingQuestion | null;
+export declare function normalizeTurns(raw: ConversationTurn[]): ConversationTurn[];
+export declare function attachArtifactsToTurns(turns: ConversationTurn[], artifacts: SessionArtifact[]): ConversationTurn[];

package/dist/chat-ui/data/openManagedEventSource.d.ts

@@ -0,0 +1,54 @@
+/**
+ * openManagedEventSource — shared EventSource primitive.
+ *
+ * Centralises the listener wiring, AbortSignal handling, and the
+ * 500ms initial-connect grace used by subscribeRunEvents and
+ * subscribeActiveRuns. Future fan-out helpers can adopt this instead
+ * of duplicating the EventSource boilerplate.
+ *
+ * Behaviour:
+ * - Registers an addEventListener for every name in `events`. The
+ *   callback receives the event name and the JSON-parsed payload.
+ * - On JSON parse failure, the callback is invoked with
+ *   `{ __unparseable: true, raw: <string> }` so the caller can log or
+ *   surface a synthetic error. The subscription stays open; native
+ *   EventSource reconnect handles transient flaps.
+ * - Initial-connect grace: when `onerror` fires before any event is
+ *   received AND within `connectGraceMs` of construction, the
+ *   returned promise rejects with either the caller-provided error
+ *   (via `onConnectError`) or a generic Error. After the grace
+ *   window expires, `onerror` is non-fatal — the browser reconnects
+ *   silently.
+ * - AbortSignal close: closing the source resolves the promise.
+ *   Already-aborted signals short-circuit before construction.
+ */
+export interface UnparseableEventPayload {
+    __unparseable: true;
+    raw: string;
+}
+export interface OpenManagedEventSourceOptions {
+    url: string;
+    /** Every named event to subscribe to via addEventListener. */
+    events: readonly string[];
+    /**
+     * Called for each event received. `data` is either the JSON-parsed
+     * payload or a sentinel `{ __unparseable: true, raw }` when the
+     * payload could not be parsed.
+     */
+    onMessage: (name: string, data: unknown) => void;
+    /** Optional hook for raw EventSource errors (all flaps, not just initial). */
+    onError?: (e: Event) => void;
+    /** Close the source and resolve the promise when the signal aborts. */
+    signal?: AbortSignal;
+    /** Forwarded to the EventSource constructor. Defaults to true. */
+    withCredentials?: boolean;
+    /** Initial-connect grace window in ms. Default 500. Set 0 to disable the probe. */
+    connectGraceMs?: number;
+    /**
+     * Maps the raw onerror Event into a rejection Error. Called only
+     * when the error fires within the grace window and before any event
+     * has been received. Defaults to a plain Error.
+     */
+    onConnectError?: (e: Event) => Error;
+}
+export declare function openManagedEventSource(opts: OpenManagedEventSourceOptions): Promise<void>;