@gravity-ui/aikit 1.4.0 → 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/aikit",
-  "version": "1.4.0",
+  "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"
   }
 }