@gravity-ui/aikit 1.3.5 → 1.5.0

package/dist/adapters/openai/types/openAiTypes.d.ts

@@ -0,0 +1,213 @@
+/**
+ * OpenAI Responses API types (source of truth: openai SDK, optionalDependencies).
+ * Compatible with openai ^6.x (Responses API).
+ * Import path: openai/resources/responses/responses.
+ * We re-use SDK types where possible; permissive variants (optional fields) only for
+ * raw SSE and partial API responses.
+ */
+import type { ResponseOutputRefusal, ResponseOutputText } from 'openai/resources/responses/responses';
+/** Minimal response shape (Response subset); all optional for partial/SSE. */
+export type OpenAIResponseLike = {
+    id?: string;
+    error?: {
+        code?: string;
+        message?: string;
+    } | null;
+    metadata?: Record<string, string> | null;
+    output?: OpenAIResponseOutputItem[] | null;
+};
+/** ResponseOutputMessage; id optional for stream/SSE. */
+export type OpenAIResponseOutputMessage = {
+    type: 'message';
+    id?: string;
+    role: 'assistant';
+    content: Array<OpenAIResponseOutputText | OpenAIResponseOutputRefusal>;
+    status?: 'in_progress' | 'completed' | 'incomplete';
+};
+/** ResponseOutputText; annotations optional for raw SSE / partial responses. */
+export type OpenAIResponseOutputText = Pick<ResponseOutputText, 'text' | 'type'> & {
+    annotations?: ResponseOutputText['annotations'];
+};
+/** Re-export from openai. */
+export type OpenAIResponseOutputRefusal = ResponseOutputRefusal;
+/** ResponseReasoningItem; id/summary optional for stream. */
+export type OpenAIResponseReasoningItem = {
+    type: 'reasoning';
+    id?: string;
+    content?: Array<{
+        type: 'reasoning_text';
+        text: string;
+    }>;
+    summary?: Array<{
+        type: string;
+        text: string;
+    }>;
+};
+/** ResponseFunctionToolCall; arguments optional for stream. */
+export type OpenAIResponseFunctionToolCall = {
+    type: 'function_call';
+    call_id: string;
+    name: string;
+    arguments?: string;
+    id?: string;
+};
+/** ResponseOutputItem.McpCall; name/server_label/arguments optional for stream. */
+export type OpenAIResponseMcpCallLike = {
+    type: 'mcp_call';
+    id: string;
+    name?: string;
+    server_label?: string;
+    arguments?: string;
+    status?: 'in_progress' | 'completed' | 'incomplete' | 'calling' | 'failed';
+    output?: string | null;
+    error?: string | null;
+};
+/** ResponseOutputItem.McpApprovalRequest; name/server_label/arguments optional for stream. */
+export type OpenAIResponseMcpApprovalRequestLike = {
+    type: 'mcp_approval_request';
+    id: string;
+    name?: string;
+    server_label?: string;
+    arguments?: string;
+};
+/** Future: if API adds mcp_submission_request, map to waitingSubmission. */
+export type OpenAIResponseMcpSubmissionRequestLike = {
+    type: 'mcp_submission_request';
+    id: string;
+    name?: string;
+    server_label?: string;
+    arguments?: string;
+};
+export type OpenAIResponseOutputItem = OpenAIResponseOutputMessage | OpenAIResponseReasoningItem | OpenAIResponseFunctionToolCall | OpenAIResponseMcpCallLike | OpenAIResponseMcpApprovalRequestLike | OpenAIResponseMcpSubmissionRequestLike | {
+    type: string;
+};
+/** Permissive item for stream events (response.output_item.added/done). */
+export type OpenAIStreamOutputItemLike = {
+    type?: string;
+    [key: string]: unknown;
+};
+/** ResponseStreamEvent-compatible; includes SSE wrapper (event/data) for raw fetch. */
+export type OpenAIStreamEventLike = {
+    type: 'response.output_text.delta';
+    delta: string;
+} | {
+    type: 'response.output_text.done';
+    text?: string;
+} | {
+    type: 'response.content_part.delta';
+    delta?: string;
+} | {
+    type: 'response.output_item.added';
+    item?: OpenAIStreamOutputItemLike;
+} | {
+    type: 'response.output_item.done';
+    item?: OpenAIStreamOutputItemLike;
+} | {
+    type: 'response.mcp_call.in_progress';
+    item_id: string;
+} | {
+    type: 'response.mcp_call.completed';
+    item_id: string;
+} | {
+    type: 'response.mcp_call.failed';
+    item_id: string;
+} | {
+    type: 'response.reasoning_text.delta';
+    item_id: string;
+    delta: string;
+} | {
+    type: 'response.reasoning_text.done';
+    item_id: string;
+    text: string;
+} | {
+    type: 'response.refusal.delta';
+    item_id: string;
+    delta: string;
+    output_index?: number;
+} | {
+    type: 'response.refusal.done';
+    item_id: string;
+    output_index?: number;
+    refusal: string;
+} | {
+    type: 'response.reasoning_summary_text.delta';
+    item_id: string;
+    delta: string;
+} | {
+    type: 'response.reasoning_summary_text.done';
+    item_id: string;
+    text: string;
+} | {
+    type: 'response.file_search_call.searching';
+    item_id: string;
+} | {
+    type: 'response.file_search_call.completed';
+    item_id: string;
+} | {
+    type: 'response.file_search_call.in_progress';
+    item_id: string;
+} | {
+    type: 'response.web_search_call.in_progress';
+    item_id: string;
+} | {
+    type: 'response.web_search_call.completed';
+    item_id: string;
+} | {
+    type: 'response.web_search_call.searching';
+    item_id: string;
+} | {
+    type: 'response.code_interpreter_call.interpreting';
+    item_id: string;
+} | {
+    type: 'response.code_interpreter_call.completed';
+    item_id: string;
+} | {
+    type: 'response.code_interpreter_call.in_progress';
+    item_id: string;
+} | {
+    type: 'response.image_generation_call.generating';
+    item_id: string;
+} | {
+    type: 'response.image_generation_call.completed';
+    item_id: string;
+} | {
+    type: 'response.image_generation_call.in_progress';
+    item_id: string;
+} | {
+    type: 'response.mcp_list_tools.in_progress';
+    item_id: string;
+} | {
+    type: 'response.mcp_list_tools.completed';
+    item_id: string;
+} | {
+    type: 'response.mcp_list_tools.failed';
+    item_id: string;
+    error?: string;
+} | {
+    type: 'response.done';
+} | {
+    type: 'response.completed';
+} | {
+    type: 'response.failed';
+} | {
+    type: 'error';
+    error?: string;
+} | {
+    event?: string;
+    data?: {
+        type?: string;
+        delta?: string;
+        text?: string;
+        item?: OpenAIStreamOutputItemLike;
+        item_id?: string;
+    };
+    item?: OpenAIStreamOutputItemLike;
+    item_id?: string;
+    error?: string;
+    refusal?: string;
+} | {
+    text?: string;
+} | {
+    type?: string;
+    [key: string]: unknown;
+};

package/dist/adapters/openai/types/openAiTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/adapters/openai/useOpenAIResponsesAdapter.d.ts

@@ -0,0 +1,12 @@
+import type { TChatMessage } from '../../types';
+import type { OpenAIStreamAdapterOptions, OpenAIStreamAdapterResult, OpenAIStreamSource } from './types';
+import { OpenAIResponseLike } from './types/openAiTypes';
+export type { OpenAIStreamAdapterOptions, OpenAIStreamAdapterResult, OpenAIStreamSource, } from './types';
+/** Single non-streaming response → TChatMessage[]. For streaming use useOpenAIStreamAdapter. */
+export declare function useOpenAIResponsesAdapter(response: OpenAIResponseLike | null): TChatMessage[];
+/**
+ * Consumes OpenAI stream (fetch SSE or AsyncIterable), returns { messages, status, error }.
+ * Only message output_item.done starts a new assistant message; MCP/tool/reasoning .done are ignored.
+ * See README for result shape and options.
+ */
+export declare function useOpenAIStreamAdapter(stream: OpenAIStreamSource | null, options?: OpenAIStreamAdapterOptions): OpenAIStreamAdapterResult;

package/dist/adapters/openai/useOpenAIResponsesAdapter.js

@@ -0,0 +1,83 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { consumeOpenAIStream } from './helpers/consumeOpenAIStream';
+import { fetchResponseToStreamEvents } from './helpers/fetchResponseToStreamEvents';
+import { isFetchResponse } from './helpers/isFetchResponse';
+import { openAIResponseToMessages } from './helpers/openAIResponseToMessages';
+/** Single non-streaming response → TChatMessage[]. For streaming use useOpenAIStreamAdapter. */
+export function useOpenAIResponsesAdapter(response) {
+    return useMemo(() => openAIResponseToMessages(response), [response]);
+}
+/**
+ * Consumes OpenAI stream (fetch SSE or AsyncIterable), returns { messages, status, error }.
+ * Only message output_item.done starts a new assistant message; MCP/tool/reasoning .done are ignored.
+ * See README for result shape and options.
+ */
+export function useOpenAIStreamAdapter(stream, options = {}) {
+    const { initialMessages = [], assistantMessageId: optionId, onStreamEnd } = options;
+    const onStreamEndRef = useRef(onStreamEnd);
+    onStreamEndRef.current = onStreamEnd;
+    const initialMessagesRef = useRef(initialMessages);
+    initialMessagesRef.current = initialMessages;
+    const [messages, setMessages] = useState(initialMessages);
+    const [status, setStatus] = useState('idle');
+    const [error, setError] = useState(null);
+    const assistantMessageId = useMemo(() => optionId !== null && optionId !== void 0 ? optionId : `assistant-${Date.now()}`, [optionId]);
+    useEffect(() => {
+        if (!stream) {
+            setStatus('idle');
+            setError(null);
+            return undefined;
+        }
+        const streamToConsume = isFetchResponse(stream)
+            ? fetchResponseToStreamEvents(stream)
+            : stream;
+        let cancelled = false;
+        setStatus('streaming');
+        setError(null);
+        const baseMessages = initialMessagesRef.current;
+        const getAssistantMessageId = (index) => index === 0 ? assistantMessageId : `${assistantMessageId}-${index}`;
+        setMessages([
+            ...baseMessages,
+            {
+                id: getAssistantMessageId(0),
+                role: 'assistant',
+                content: '',
+            },
+        ]);
+        const callbacks = {
+            baseMessages,
+            getAssistantMessageId,
+            onContentUpdate: (messageId, content) => {
+                if (cancelled)
+                    return;
+                setMessages((prev) => prev.map((msg) => msg.id === messageId && msg.role === 'assistant'
+                    ? Object.assign(Object.assign({}, msg), { content })
+                    : msg));
+            },
+            onNewMessage: (messageId) => {
+                if (cancelled)
+                    return;
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        id: messageId,
+                        role: 'assistant',
+                        content: '',
+                    },
+                ]);
+            },
+            onEnd: (finalMessages, s, err) => {
+                var _a;
+                setStatus(s);
+                setError(err !== null && err !== void 0 ? err : null);
+                (_a = onStreamEndRef.current) === null || _a === void 0 ? void 0 : _a.call(onStreamEndRef, finalMessages);
+            },
+            getIsCancelled: () => cancelled,
+        };
+        consumeOpenAIStream(streamToConsume, callbacks);
+        return () => {
+            cancelled = true;
+        };
+    }, [stream, assistantMessageId]);
+    return { messages, status, error };
+}

package/dist/components/organisms/MessageList/MessageList.js

@@ -9,8 +9,8 @@ import { UserMessage } from '../UserMessage';
 import { ErrorAlert } from './ErrorAlert';
 import './MessageList.scss';
 const b = block('message-list');
-export function MessageList({ messages, messageRendererRegistry, transformOptions, shouldParseIncompleteMarkdown, showActionsOnHover, showTimestamp, showAvatar, userActions, assistantActions, loaderStatuses = ['submitted'], className, qa, status, errorMessage, onRetry, hasPreviousMessages = false, onLoadPreviousMessages, }) {
-    const isStreaming = status === 'streaming';
+export function MessageList({ messages, messageRendererRegistry, transformOptions, shouldParseIncompleteMarkdown, showActionsOnHover, showTimestamp, showAvatar, userActions, assistantActions, loaderStatuses = ['submitted', 'streaming_loading'], className, qa, status, errorMessage, onRetry, hasPreviousMessages = false, onLoadPreviousMessages, }) {
+    const isStreaming = status === 'streaming' || status === 'streaming_loading';
     const isSubmitted = status === 'submitted';
     const showLoader = status && loaderStatuses.includes(status);
     const { containerRef } = useSmartScroll({

package/dist/components/organisms/PromptInput/usePromptInput.js

@@ -16,6 +16,7 @@ export function usePromptInput(props) {
     // ChatStatus.ready → submitButtonState.enabled
     // ChatStatus.error → submitButtonState.enabled
     // ChatStatus.streaming → submitButtonState.cancelable
+    // ChatStatus.streaming_loading → submitButtonState.cancelable (same as streaming)
     // ChatStatus.submitted → submitButtonState.loading
     let submitButtonState = 'disabled';
     // disabled by props or empty value and status is ready
@@ -32,6 +33,7 @@ export function usePromptInput(props) {
                 submitButtonState = 'enabled';
                 break;
             case 'streaming':
+            case 'streaming_loading':
                 submitButtonState = onCancel ? 'cancelable' : 'enabled';
                 break;
             case 'submitted':

package/dist/components/pages/ChatContainer/__stories__/ChatContainer.stories.js

@@ -359,9 +359,16 @@ export const WithStreaming = {
                     actions: createMessageActions(assistantMessageId, 'assistant'),
                 },
             ]);
-            // Simulate word-by-word streaming
+            // Simulate word-by-word streaming with a streaming_loading pause in the middle
             const words = fullResponse.split(' ');
+            const pauseIndex = Math.floor(words.length / 2);
             for (let i = 0; i < words.length; i++) {
+                // Pause streaming at the midpoint: switch to streaming_loading for 5 seconds
+                if (i === pauseIndex) {
+                    setStatus('streaming_loading');
+                    await new Promise((resolve) => setTimeout(resolve, 5000));
+                    setStatus('streaming');
+                }
                 await new Promise((resolve) => setTimeout(resolve, 100));
                 const currentText = words.slice(0, i + 1).join(' ');
                 setMessages((prev) => prev.map((msg) => msg.id === assistantMessageId
@@ -747,7 +754,10 @@ export const FullStreamingExample = {
         const [controller, setController] = useState(null);
         const isProcessingRef = React.useRef(false);
         const handleSendMessage = async (data) => {
-            if (isProcessingRef.current || status === 'streaming' || status === 'submitted') {
+            if (isProcessingRef.current ||
+                status === 'streaming' ||
+                status === 'streaming_loading' ||
+                status === 'submitted') {
                 return;
             }
             isProcessingRef.current = true;

package/dist/index.d.ts

@@ -7,5 +7,6 @@ export * from './components/molecules';
 export * from './components/organisms';
 export * from './components/templates';
 export * from './components/pages';
+export * from './adapters';
 export * from './hooks';
 export * from './utils';

package/dist/index.js

@@ -13,6 +13,8 @@ export * from './components/organisms';
 export * from './components/templates';
 // === Pages ===
 export * from './components/pages';
+// === Adapters ===
+export * from './adapters';
 // === Hooks ===
 export * from './hooks';
 // === Utilities ===

package/dist/types/chat.d.ts

@@ -5,7 +5,7 @@ export type ChatType = {
     lastMessage?: string;
     metadata?: Record<string, unknown>;
 };
-export type ChatStatus = 'submitted' | 'streaming' | 'ready' | 'error';
+export type ChatStatus = 'submitted' | 'streaming' | 'streaming_loading' | 'ready' | 'error';
 /**
  * List item type for chat history that can be either a chat or a date header
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/aikit",
-  "version": "1.3.5",
+  "version": "1.5.0",
   "description": "Gravity UI base kit for building ai assistant chats",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -145,5 +145,8 @@
     "react-window": "^2.2.1",
     "remend": "^1.0.1",
     "uuid": "^13.0.0"
+  },
+  "optionalDependencies": {
+    "openai": "^6.22.0"
   }
 }