@iota-uz/sdk 0.19.0 → 0.21.0

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

@@ -0,0 +1,421 @@
+export type BichatRPC = {
+    "bichat.artifact.delete": {
+        params: ArtifactIDParams;
+        result: OkResult;
+    };
+    "bichat.artifact.update": {
+        params: ArtifactUpdateParams;
+        result: ArtifactResult;
+    };
+    "bichat.ping": {
+        params: PingParams;
+        result: PingResult;
+    };
+    "bichat.question.reject": {
+        params: QuestionCancelParams;
+        result: AsyncRunAcceptedResult;
+    };
+    "bichat.question.submit": {
+        params: QuestionSubmitParams;
+        result: AsyncRunAcceptedResult;
+    };
+    "bichat.session.archive": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.artifacts": {
+        params: SessionArtifactsParams;
+        result: SessionArtifactsResult;
+    };
+    "bichat.session.clear": {
+        params: SessionIDParams;
+        result: SessionClearResult;
+    };
+    "bichat.session.compact": {
+        params: SessionIDParams;
+        result: AsyncRunAcceptedResult;
+    };
+    "bichat.session.create": {
+        params: SessionCreateParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.delete": {
+        params: SessionIDParams;
+        result: OkResult;
+    };
+    "bichat.session.get": {
+        params: SessionGetParams;
+        result: SessionGetResult;
+    };
+    "bichat.session.list": {
+        params: SessionListParams;
+        result: SessionListResult;
+    };
+    "bichat.session.listAll": {
+        params: SessionListAllParams;
+        result: SessionListAllResult;
+    };
+    "bichat.session.members.add": {
+        params: SessionMembersUpsertParams;
+        result: OkResult;
+    };
+    "bichat.session.members.list": {
+        params: SessionMembersListParams;
+        result: SessionMembersListResult;
+    };
+    "bichat.session.members.remove": {
+        params: SessionMembersRemoveParams;
+        result: OkResult;
+    };
+    "bichat.session.members.updateRole": {
+        params: SessionMembersUpsertParams;
+        result: OkResult;
+    };
+    "bichat.session.pin": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.regenerateTitle": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.unarchive": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.unpin": {
+        params: SessionIDParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.updateTitle": {
+        params: SessionUpdateTitleParams;
+        result: SessionCreateResult;
+    };
+    "bichat.session.uploadArtifacts": {
+        params: SessionUploadArtifactsParams;
+        result: SessionUploadArtifactsResult;
+    };
+    "bichat.user.list": {
+        params: UserListParams;
+        result: UserListResult;
+    };
+};
+export interface Artifact {
+    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 interface ArtifactIDParams {
+    id: string;
+}
+export interface ArtifactResult {
+    artifact: Artifact;
+}
+export interface ArtifactUpdateParams {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface AssistantTurn {
+    id: string;
+    role?: string;
+    content: string;
+    explanation?: string;
+    citations: Citation[];
+    toolCalls?: ToolCall[];
+    debug?: DebugTrace | null;
+    artifacts: unknown[];
+    codeOutputs: CodeOutput[];
+    createdAt: string;
+}
+export interface AsyncRunAcceptedResult {
+    accepted: boolean;
+    operation: string;
+    sessionId: string;
+    runId: string;
+    startedAt: number;
+}
+export interface Attachment {
+    id: string;
+    uploadId?: number | null;
+    filename: string;
+    mimeType: string;
+    sizeBytes: number;
+    url?: string;
+}
+export interface Citation {
+    id: string;
+    type: string;
+    title: string;
+    url: string;
+    startIndex: number;
+    endIndex: number;
+    excerpt?: string;
+    source?: string;
+}
+export interface CodeOutput {
+    type: string;
+    content: string;
+    filename?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+}
+export interface ConversationTurn {
+    id: string;
+    sessionId: string;
+    userTurn: UserTurn;
+    assistantTurn?: AssistantTurn | null;
+    createdAt: string;
+}
+export interface DebugEvent {
+    id?: string;
+    name?: string;
+    type?: string;
+    level?: string;
+    message?: string;
+    reason?: string;
+    spanId?: string;
+    generationId?: string;
+    timestamp?: string;
+    attributes?: Record<string, unknown>;
+}
+export interface DebugGeneration {
+    id?: string;
+    requestId?: string;
+    model?: string;
+    provider?: string;
+    finishReason?: string;
+    promptTokens?: number;
+    completionTokens?: number;
+    totalTokens?: number;
+    cachedTokens?: number;
+    cost?: number;
+    latencyMs?: number;
+    input?: string;
+    output?: string;
+    thinking?: string;
+    observationReason?: string;
+    startedAt?: string;
+    completedAt?: string;
+    toolCalls?: DebugToolCall[];
+}
+export interface DebugSpan {
+    id?: string;
+    parentId?: string;
+    generationId?: string;
+    name?: string;
+    type?: string;
+    status?: string;
+    level?: string;
+    callId?: string;
+    toolName?: string;
+    input?: string;
+    output?: string;
+    error?: string;
+    durationMs?: number;
+    startedAt?: string;
+    completedAt?: string;
+    attributes?: Record<string, unknown>;
+}
+export interface DebugToolCall {
+    callId?: string;
+    name?: string;
+    arguments?: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
+}
+export interface DebugTrace {
+    schemaVersion?: string;
+    startedAt?: string;
+    completedAt?: string;
+    usage?: DebugUsage | null;
+    generationMs?: number;
+    tools?: DebugToolCall[];
+    attempts?: DebugGeneration[];
+    spans?: DebugSpan[];
+    events?: DebugEvent[];
+    traceId?: string;
+    traceUrl?: string;
+    sessionId?: string;
+    thinking?: string;
+    observationReason?: string;
+}
+export interface DebugUsage {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    cost: number;
+}
+export interface OkResult {
+    ok: boolean;
+}
+export interface PendingQuestion {
+    checkpointId: string;
+    agentName?: string;
+    turnId: string;
+    questions: PendingQuestionItem[];
+    status: string;
+}
+export interface PendingQuestionItem {
+    id: string;
+    text: string;
+    type: string;
+    options: PendingQuestionOption[];
+}
+export interface PendingQuestionOption {
+    id: string;
+    label: string;
+}
+export type PingParams = Record<string, never>;
+export interface PingResult {
+    ok: boolean;
+    tenantId: string;
+}
+export interface QuestionCancelParams {
+    sessionId: string;
+}
+export interface QuestionSubmitParams {
+    sessionId: string;
+    checkpointId: string;
+    answers: Record<string, string>;
+}
+export interface Session {
+    id: string;
+    title: string;
+    status: string;
+    pinned: boolean;
+    createdAt: string;
+    updatedAt: string;
+    owner?: SessionUser | null;
+    isGroup?: boolean;
+    memberCount?: number;
+    access?: SessionAccess | null;
+}
+export interface SessionAccess {
+    role: string;
+    source: string;
+    canRead: boolean;
+    canWrite: boolean;
+    canManageMembers: boolean;
+}
+export interface SessionArtifactsParams {
+    sessionId: string;
+    limit: number;
+    offset: number;
+}
+export interface SessionArtifactsResult {
+    artifacts: Artifact[];
+    hasMore: boolean;
+    nextOffset: number;
+}
+export interface SessionClearResult {
+    success: boolean;
+    deletedMessages: number;
+    deletedArtifacts: number;
+}
+export interface SessionCreateParams {
+    title: string;
+}
+export interface SessionCreateResult {
+    session: Session;
+}
+export interface SessionGetParams {
+    id: string;
+}
+export interface SessionGetResult {
+    session: Session;
+    turns: ConversationTurn[];
+    pendingQuestion?: PendingQuestion | null;
+}
+export interface SessionIDParams {
+    id: string;
+}
+export interface SessionListAllParams {
+    limit: number;
+    offset: number;
+    includeArchived: boolean;
+    userId?: string | null;
+}
+export interface SessionListAllResult {
+    sessions: Session[];
+    total?: number;
+    hasMore: boolean;
+}
+export interface SessionListParams {
+    limit: number;
+    offset: number;
+    includeArchived: boolean;
+}
+export interface SessionListResult {
+    sessions: Session[];
+    total?: number;
+    hasMore: boolean;
+}
+export interface SessionMember {
+    user: SessionUser;
+    role: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SessionMembersListParams {
+    sessionId: string;
+}
+export interface SessionMembersListResult {
+    members: SessionMember[];
+}
+export interface SessionMembersRemoveParams {
+    sessionId: string;
+    userId: string;
+}
+export interface SessionMembersUpsertParams {
+    sessionId: string;
+    userId: string;
+    role: string;
+}
+export interface SessionUpdateTitleParams {
+    id: string;
+    title: string;
+}
+export interface SessionUploadArtifactsParams {
+    sessionId: string;
+    attachments: Attachment[];
+}
+export interface SessionUploadArtifactsResult {
+    artifacts: Artifact[];
+}
+export interface SessionUser {
+    id: string;
+    firstName: string;
+    lastName: string;
+    initials: string;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+    result?: string;
+    error?: string;
+    durationMs?: number;
+}
+export type UserListParams = Record<string, never>;
+export interface UserListResult {
+    users: SessionUser[];
+}
+export interface UserTurn {
+    id: string;
+    content: string;
+    attachments: Attachment[];
+    author?: SessionUser | null;
+    createdAt: string;
+}

package/dist/chat-ui/hooks/createHorizontalSwipe.d.ts

@@ -0,0 +1,27 @@
+export interface SwipeInfo {
+    offset: {
+        x: number;
+        y: number;
+    };
+    velocity: {
+        x: number;
+        y: number;
+    };
+}
+export declare function createHorizontalSwipe(options: {
+    enabled?: () => boolean;
+    left?: number;
+    right?: number;
+    onStart?: () => void;
+    onEnd?: (event: PointerEvent, info: SwipeInfo) => void;
+}): {
+    offset: import("solid-js").Accessor<number>;
+    handlers: {
+        onPointerDown(event: PointerEvent & {
+            currentTarget: HTMLElement;
+        }): void;
+        onPointerMove(event: PointerEvent): void;
+        onPointerUp(event: PointerEvent): void;
+        onPointerCancel(event: PointerEvent): void;
+    };
+};

package/dist/chat-ui/hooks/createReducedMotion.d.ts

@@ -0,0 +1 @@
+export declare function createReducedMotion(): import("solid-js").Accessor<boolean>;

package/dist/chat-ui/hooks/useActiveRuns.d.ts

@@ -0,0 +1,47 @@
+/**
+ * useActiveRuns — live map of per-session generation status.
+ *
+ * Subscribes to the data source's `subscribeActiveRuns` channel
+ * (`GET /bi-chat/stream/active-runs`) and maintains a
+ * sessionId → status dictionary so the sidebar can render a status
+ * dot next to each session card without polling /stream/status per
+ * session.
+ *
+ * The hook is a no-op when:
+ * - the data source does not implement subscribeActiveRuns (older
+ *   backends without the active-run index);
+ * - `enabled` is false (e.g. the user is offline).
+ */
+import type { ActiveRunDelivery, ChatDataSource } from '../types';
+export interface ActiveRunSnapshot {
+    runId: string;
+    status: ActiveRunDelivery['status'];
+    updatedAt: number;
+}
+export interface UseActiveRunsOptions {
+    enabled?: boolean;
+    /** Optional hook for raw SSE errors. */
+    onError?: (event: Event) => void;
+    /**
+     * Keep terminal-status entries in the map for this many milliseconds
+     * before pruning them. Default 0 preserves the previous behaviour
+     * (synchronous delete). Useful when consumers want to render a
+     * "completed" pulse animation before the dot disappears.
+     */
+    retainTerminalMs?: number;
+    /**
+     * How long to wait for an initial snapshot batch before declaring
+     * the hook `ready` when the server has zero active runs.
+     * Default 250ms.
+     */
+    emptyStateTimeoutMs?: number;
+}
+export interface UseActiveRunsResult {
+    /** sessionId → current live status. Terminal statuses are emitted then the entry is removed. */
+    runs: Record<string, ActiveRunSnapshot>;
+    /** True once the initial HGETALL snapshot is delivered. */
+    ready: boolean;
+    /** Convenience: undefined when not active. */
+    status: (sessionId: string) => ActiveRunDelivery['status'] | undefined;
+}
+export declare function useActiveRuns(source: Pick<ChatDataSource, 'subscribeActiveRuns'> | (() => Pick<ChatDataSource, 'subscribeActiveRuns'>), options?: UseActiveRunsOptions): UseActiveRunsResult;

package/dist/chat-ui/hooks/useAttachments.d.ts

@@ -0,0 +1,80 @@
+/**
+ * useAttachments Hook
+ * Manages file upload state, validation, and preview
+ */
+import type { Attachment } from '../types';
+export interface FileValidationError {
+    file: File;
+    reason: 'size' | 'type' | 'count' | 'custom';
+    message: string;
+}
+export interface UseAttachmentsOptions {
+    /** Maximum number of files (default: 10) */
+    maxFiles?: number;
+    /** Maximum file size in bytes (default: 20MB) */
+    maxFileSize?: number;
+    /** Allowed MIME types (default: attachment allowlist) */
+    allowedTypes?: string[];
+    /** Custom validation function */
+    validate?: (file: File) => string | null;
+    /** Callback when files are added */
+    onAdd?: (files: Attachment[]) => void;
+    /** Callback when a file is removed */
+    onRemove?: (file: Attachment) => void;
+    /** Callback when validation fails */
+    onError?: (errors: FileValidationError[]) => void;
+}
+export interface UseAttachmentsReturn {
+    /** Current attachments */
+    files: Attachment[];
+    /** Validation errors from last operation */
+    errors: FileValidationError[];
+    /** Whether files are being processed */
+    isProcessing: boolean;
+    /** Whether max file limit is reached */
+    isMaxReached: boolean;
+    /** Number of remaining slots */
+    remainingSlots: number;
+    /** Add files (validates and processes) */
+    add: (files: FileList | File[]) => Promise<void>;
+    /** Remove a specific file */
+    remove: (fileOrId: Attachment | string) => void;
+    /** Clear all files */
+    clear: () => void;
+    /** Clear errors */
+    clearErrors: () => void;
+    /** Set files directly (for controlled mode) */
+    setFiles: (files: Attachment[]) => void;
+}
+/**
+ * Hook for managing file attachments
+ *
+ * @example
+ * ```tsx
+ * const attachments = useAttachments({
+ *   maxFiles: 5,
+ *   maxFileSize: 5 * 1024 * 1024, // 5MB
+ *   onError: (errors) => errors.forEach(e => toast.error(e.message)),
+ * })
+ *
+ * <input
+ *   type="file"
+ *   multiple
+ *   accept="image/*"
+ *   onChange={(e) => attachments.add(e.target.files)}
+ * />
+ *
+ * {attachments.files.map(file => (
+ *   <AttachmentPreview
+ *     key={file.id}
+ *     attachment={file}
+ *     onRemove={() => attachments.remove(file)}
+ *   />
+ * ))}
+ *
+ * {attachments.errors.length > 0 && (
+ *   <ErrorList errors={attachments.errors} />
+ * )}
+ * ```
+ */
+export declare function useAttachments(options?: UseAttachmentsOptions): UseAttachmentsReturn;

package/dist/chat-ui/hooks/useAutoScroll.d.ts

@@ -0,0 +1,51 @@
+/**
+ * useAutoScroll Hook
+ * Manages auto-scroll behavior for chat containers
+ */
+export interface UseAutoScrollOptions {
+    /** Threshold in pixels from bottom to consider "at bottom" (default: 100) */
+    threshold?: number;
+    /** Smooth scroll behavior (default: true) */
+    smooth?: boolean;
+    /** Callback when scroll position changes */
+    onScroll?: (isAtBottom: boolean) => void;
+}
+export interface UseAutoScrollReturn {
+    /** Ref to attach to the scrollable container */
+    containerRef: {
+        current: HTMLDivElement | null;
+    };
+    /** Whether the container is scrolled to the bottom */
+    isAtBottom: boolean;
+    /** Whether auto-scroll should be active */
+    shouldAutoScroll: boolean;
+    /** Manually scroll to bottom */
+    scrollToBottom: (smooth?: boolean) => void;
+    /** Enable/disable auto-scroll */
+    setAutoScroll: (enabled: boolean) => void;
+    /** Handle scroll event (attach to container if not using ref) */
+    handleScroll: (e: UIEvent & {
+        currentTarget: HTMLDivElement;
+    }) => void;
+}
+/**
+ * Hook for managing auto-scroll behavior in chat containers
+ *
+ * @example
+ * ```tsx
+ * const scroll = useAutoScroll({ threshold: 50 })
+ *
+ * // Attach to container
+ * <div ref={scroll.containerRef} onScroll={scroll.handleScroll}>
+ *   {messages.map(msg => <Message key={msg.id} />)}
+ * </div>
+ *
+ * // Scroll button
+ * {!scroll.isAtBottom && (
+ *   <button onClick={() => scroll.scrollToBottom()}>
+ *     Scroll to bottom
+ *   </button>
+ * )}
+ * ```
+ */
+export declare function useAutoScroll(options?: UseAutoScrollOptions): UseAutoScrollReturn;

package/dist/chat-ui/hooks/useBichatRouter.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Router adapter for BiChat sidebar and archived list.
+ * Consumes a navigate function and location (pathname) and returns
+ * activeSessionId plus callbacks for use with SDK Sidebar and ArchivedChatList.
+ *
+ * Router-agnostic: pass useNavigate()/useLocation() from react-router-dom
+ * or equivalent from your router.
+ */
+export interface UseBichatRouterParams {
+    /** Navigate to a path (e.g. from useNavigate()) */
+    navigate: (path: string) => void;
+    /** Current pathname (e.g. location.pathname from useLocation()) */
+    pathname: string;
+    /** Optional: close mobile sidebar after navigation (e.g. closeMobile from useSidebarState) */
+    onNavigate?: () => void;
+}
+export interface UseBichatRouterReturn {
+    /** Session ID extracted from pathname (e.g. /session/:id -> id) */
+    activeSessionId: string | undefined;
+    /** Navigate to session or home when sessionId is empty */
+    onSessionSelect: (sessionId: string) => void;
+    /** Navigate to new chat (home) */
+    onNewChat: () => void;
+    /** Navigate to archived list */
+    onArchivedView: () => void;
+    /** Navigate back (e.g. to home) */
+    onBack: () => void;
+    /** Navigate to all-chats view */
+    onAllChatsView: () => void;
+    /** Current sidebar tab derived from URL */
+    sidebarTab: 'my-chats' | 'all-chats';
+    /** Handler to change sidebar tab (navigates to appropriate URL) */
+    onSidebarTabChange: (tab: 'my-chats' | 'all-chats') => void;
+}
+/**
+ * Derives BiChat navigation callbacks and activeSessionId from router state.
+ * Use with SDK Sidebar (onSessionSelect, onNewChat, onArchivedView, activeSessionId)
+ * and ArchivedChatList (onBack, onSessionSelect).
+ */
+export declare function useBichatRouter(solidProps1: UseBichatRouterParams): UseBichatRouterReturn;

package/dist/chat-ui/hooks/useBranding.d.ts

@@ -0,0 +1,16 @@
+import type { BrandingConfig } from '../types';
+/**
+ * Hook to access branding configuration.
+ *
+ * Returns merged branding with fallbacks to defaults and translations.
+ */
+export declare function useBranding(): BrandingConfig;
+/**
+ * Hook to access feature flags.
+ */
+export declare function useFeatureFlags(): {
+    vision: boolean;
+    webSearch: boolean;
+    codeInterpreter: boolean;
+    multiAgent: boolean;
+};