@gravity-ui/aikit 1.3.5 → 1.5.0

package/dist/adapters/index.d.ts

@@ -0,0 +1 @@
+export * from './openai';

package/dist/adapters/index.js

@@ -0,0 +1 @@
+export * from './openai';

package/dist/adapters/openai/helpers/applyContentUpdate.d.ts

@@ -0,0 +1,3 @@
+import type { TMessageContentUnion } from '../../../types';
+import type { StreamEventContentUpdate } from './getStreamEventContentUpdate';
+export declare function applyContentUpdate(parts: TMessageContentUnion[], update: StreamEventContentUpdate): TMessageContentUnion[] | null;

package/dist/adapters/openai/helpers/applyContentUpdate.js

@@ -0,0 +1,113 @@
+function findContentPartIndex(parts, partType, id) {
+    return parts.findIndex((p) => p.type === partType && p.id === id);
+}
+export function applyContentUpdate(parts, update) {
+    switch (update.kind) {
+        case 'text_delta':
+            return applyTextDelta(parts, update);
+        case 'tool_add':
+            return applyToolAdd(parts, update);
+        case 'tool_update':
+            return applyToolUpdate(parts, update);
+        case 'thinking_add':
+            return applyThinkingAdd(parts, update);
+        case 'thinking_delta':
+            return applyThinkingDelta(parts, update);
+        case 'thinking_done':
+            return applyThinkingDone(parts, update);
+        default:
+            return null;
+    }
+}
+function applyTextDelta(parts, update) {
+    const last = parts[parts.length - 1];
+    if ((last === null || last === void 0 ? void 0 : last.type) === 'text') {
+        return [
+            ...parts.slice(0, -1),
+            { type: 'text', data: { text: last.data.text + update.delta } },
+        ];
+    }
+    return [...parts, { type: 'text', data: { text: update.delta } }];
+}
+function applyToolAdd(parts, update) {
+    var _a;
+    const status = (_a = update.status) !== null && _a !== void 0 ? _a : 'loading';
+    const data = {
+        toolName: update.toolName,
+        status,
+    };
+    if (update.headerContent !== undefined) {
+        data.headerContent = update.headerContent;
+    }
+    return [
+        ...parts,
+        {
+            type: 'tool',
+            id: update.id,
+            data,
+        },
+    ];
+}
+function applyToolUpdate(parts, update) {
+    var _a, _b;
+    let idx = findContentPartIndex(parts, 'tool', update.item_id);
+    let partsToUpdate = parts;
+    if (idx < 0) {
+        partsToUpdate = applyToolAdd(parts, {
+            kind: 'tool_add',
+            id: update.item_id,
+            toolName: (_a = update.toolName) !== null && _a !== void 0 ? _a : '',
+            status: update.status,
+            headerContent: (_b = update.output) !== null && _b !== void 0 ? _b : update.error,
+        });
+        idx = partsToUpdate.length - 1;
+    }
+    const prev = partsToUpdate[idx];
+    if (prev.type !== 'tool')
+        return partsToUpdate;
+    return partsToUpdate.map((p, i) => {
+        var _a, _b;
+        return i === idx
+            ? Object.assign(Object.assign({}, prev), { data: Object.assign(Object.assign(Object.assign({}, prev.data), (update.toolName && { toolName: update.toolName })), { status: update.status, headerContent: (_b = (_a = update.output) !== null && _a !== void 0 ? _a : update.error) !== null && _b !== void 0 ? _b : prev.data.headerContent }) }) : p;
+    });
+}
+function applyThinkingAdd(parts, update) {
+    return [
+        ...parts,
+        {
+            type: 'thinking',
+            id: update.item_id,
+            data: {
+                content: '',
+                status: 'thinking',
+                defaultExpanded: false,
+            },
+        },
+    ];
+}
+function applyThinkingDelta(parts, update) {
+    const idx = findContentPartIndex(parts, 'thinking', update.item_id);
+    if (idx < 0 || parts[idx].type !== 'thinking') {
+        return null;
+    }
+    const prev = parts[idx];
+    const prevContent = prev.data.content;
+    let prevText = '';
+    if (typeof prevContent === 'string') {
+        prevText = prevContent;
+    }
+    else if (Array.isArray(prevContent)) {
+        prevText = prevContent.join('');
+    }
+    const newContent = prevText + update.delta;
+    return parts.map((p, i) => i === idx ? Object.assign(Object.assign({}, prev), { data: Object.assign(Object.assign({}, prev.data), { content: newContent }) }) : p);
+}
+function applyThinkingDone(parts, update) {
+    const idx = findContentPartIndex(parts, 'thinking', update.item_id);
+    if (idx < 0 || parts[idx].type !== 'thinking') {
+        return null;
+    }
+    const prev = parts[idx];
+    return parts.map((p, i) => i === idx
+        ? Object.assign(Object.assign({}, prev), { data: Object.assign(Object.assign({}, prev.data), { content: update.text, status: 'thought' }) }) : p);
+}

package/dist/adapters/openai/helpers/buildFinalMessages.d.ts

@@ -0,0 +1,11 @@
+import type { TAssistantMessage, TChatMessage, TMessageContentUnion } from '../../../types';
+export type BuildFinalMessagesParams = {
+    baseMessages: TChatMessage[];
+    completedAssistantMessages: {
+        id: string;
+        content: TAssistantMessage['content'];
+    }[];
+    currentAssistantMessageId: string;
+    contentParts: TMessageContentUnion[];
+};
+export declare function buildFinalMessages(params: BuildFinalMessagesParams): TChatMessage[];

package/dist/adapters/openai/helpers/buildFinalMessages.js

@@ -0,0 +1,27 @@
+import { contentPartsToMessageContent } from './contentPartsToMessageContent';
+function isMessageContentEmpty(content) {
+    if (typeof content === 'string')
+        return content.trim() === '';
+    return Array.isArray(content) && content.length === 0;
+}
+export function buildFinalMessages(params) {
+    const { baseMessages, completedAssistantMessages, currentAssistantMessageId, contentParts } = params;
+    const currentContent = contentPartsToMessageContent(contentParts);
+    const completedWithContent = completedAssistantMessages.filter((m) => !isMessageContentEmpty(m.content));
+    const result = [...baseMessages];
+    for (const m of completedWithContent) {
+        result.push({
+            id: m.id,
+            role: 'assistant',
+            content: m.content,
+        });
+    }
+    if (!isMessageContentEmpty(currentContent)) {
+        result.push({
+            id: currentAssistantMessageId,
+            role: 'assistant',
+            content: currentContent,
+        });
+    }
+    return result;
+}

package/dist/adapters/openai/helpers/consumeOpenAIStream.d.ts

@@ -0,0 +1,12 @@
+import type { TAssistantMessage, TChatMessage } from '../../../types';
+import type { OpenAIStreamEventLike } from '../types';
+export type ConsumeStreamCallbacks = {
+    baseMessages: TChatMessage[];
+    getAssistantMessageId: (index: number) => string;
+    onContentUpdate: (messageId: string, content: TAssistantMessage['content']) => void;
+    onNewMessage: (messageId: string) => void;
+    onEnd: (finalMessages: TChatMessage[], status: 'done' | 'error', error?: Error) => void;
+    getIsCancelled: () => boolean;
+};
+/** Consumes stream, invokes callbacks. State/setters live in caller. */
+export declare function consumeOpenAIStream(stream: AsyncIterable<OpenAIStreamEventLike>, callbacks: ConsumeStreamCallbacks): Promise<void>;

package/dist/adapters/openai/helpers/consumeOpenAIStream.js

@@ -0,0 +1,101 @@
+import { __asyncValues } from "tslib";
+import { applyContentUpdate } from './applyContentUpdate';
+import { buildFinalMessages } from './buildFinalMessages';
+import { contentPartsToMessageContent } from './contentPartsToMessageContent';
+import { getStreamErrorMessage } from './getStreamErrorMessage';
+import { getStreamEventContentUpdate } from './getStreamEventContentUpdate';
+import { isMessageOutputItemDoneEvent } from './isMessageOutputItemDoneEvent';
+import { isStreamEndOrErrorEvent } from './isStreamEndOrErrorEvent';
+/** Consumes stream, invokes callbacks. State/setters live in caller. */
+export async function consumeOpenAIStream(stream, callbacks) {
+    var _a, e_1, _b, _c;
+    const { baseMessages, getAssistantMessageId, onContentUpdate, onNewMessage, onEnd, getIsCancelled, } = callbacks;
+    const completedAssistantMessages = [];
+    let messageIndex = 0;
+    let currentAssistantMessageId = getAssistantMessageId(0);
+    let contentParts = [];
+    const applyContentToCurrentMessage = (parts) => {
+        if (getIsCancelled())
+            return;
+        onContentUpdate(currentAssistantMessageId, contentPartsToMessageContent(parts));
+    };
+    try {
+        try {
+            for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = await stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                _c = stream_1_1.value;
+                _d = false;
+                const event = _c;
+                if (getIsCancelled())
+                    return;
+                if (isStreamEndOrErrorEvent(event)) {
+                    const e = event;
+                    const finalMessages = buildFinalMessages({
+                        baseMessages,
+                        completedAssistantMessages,
+                        currentAssistantMessageId,
+                        contentParts,
+                    });
+                    if (e.type === 'error' || e.event === 'error' || e.error) {
+                        if (getIsCancelled())
+                            return;
+                        onEnd(finalMessages, 'error', new Error(getStreamErrorMessage(e)));
+                    }
+                    else {
+                        if (getIsCancelled())
+                            return;
+                        onEnd(finalMessages, 'done');
+                    }
+                    return;
+                }
+                if (isMessageOutputItemDoneEvent(event)) {
+                    completedAssistantMessages.push({
+                        id: currentAssistantMessageId,
+                        content: contentPartsToMessageContent(contentParts),
+                    });
+                    messageIndex += 1;
+                    currentAssistantMessageId = getAssistantMessageId(messageIndex);
+                    contentParts = [];
+                    if (getIsCancelled())
+                        return;
+                    onNewMessage(currentAssistantMessageId);
+                    continue;
+                }
+                const update = getStreamEventContentUpdate(event);
+                if (!update)
+                    continue;
+                const nextParts = applyContentUpdate(contentParts, update);
+                if (nextParts !== null) {
+                    contentParts = nextParts;
+                    applyContentToCurrentMessage(contentParts);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = stream_1.return)) await _b.call(stream_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (!getIsCancelled()) {
+            const finalMessages = buildFinalMessages({
+                baseMessages,
+                completedAssistantMessages,
+                currentAssistantMessageId,
+                contentParts,
+            });
+            onEnd(finalMessages, 'done');
+        }
+    }
+    catch (err) {
+        if (!getIsCancelled()) {
+            const finalMessages = buildFinalMessages({
+                baseMessages,
+                completedAssistantMessages,
+                currentAssistantMessageId,
+                contentParts,
+            });
+            onEnd(finalMessages, 'error', err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+}

package/dist/adapters/openai/helpers/contentPartsToMessageContent.d.ts

@@ -0,0 +1,2 @@
+import type { TAssistantMessage, TMessageContentUnion } from '../../../types';
+export declare function contentPartsToMessageContent(parts: TMessageContentUnion[]): TAssistantMessage['content'];

package/dist/adapters/openai/helpers/contentPartsToMessageContent.js

@@ -0,0 +1,7 @@
+export function contentPartsToMessageContent(parts) {
+    if (parts.length === 0)
+        return '';
+    if (parts.length === 1 && parts[0].type === 'text')
+        return parts[0].data.text;
+    return [...parts];
+}

package/dist/adapters/openai/helpers/eventTypeUtils.d.ts

@@ -0,0 +1,4 @@
+type EventRecord = Record<string, unknown>;
+export declare function isEventOneOf(e: EventRecord, data: EventRecord | undefined, types: string[]): boolean;
+export declare function getDeltaForEventTypes(e: EventRecord, data: EventRecord | undefined, eventTypes: string[]): string | null;
+export {};

package/dist/adapters/openai/helpers/eventTypeUtils.js

@@ -0,0 +1,17 @@
+export function isEventOneOf(e, data, types) {
+    const t = e.type;
+    const ev = e.event;
+    const dt = data === null || data === void 0 ? void 0 : data.type;
+    return types.some((type) => t === type || ev === type || dt === type);
+}
+export function getDeltaForEventTypes(e, data, eventTypes) {
+    var _a, _b;
+    if (eventTypes.includes((_a = e.type) !== null && _a !== void 0 ? _a : '') && typeof e.delta === 'string') {
+        return e.delta;
+    }
+    if (!isEventOneOf(e, data, eventTypes)) {
+        return null;
+    }
+    const delta = ((_b = data === null || data === void 0 ? void 0 : data.delta) !== null && _b !== void 0 ? _b : e.delta);
+    return typeof delta === 'string' ? delta : null;
+}

package/dist/adapters/openai/helpers/fetchResponseToStreamEvents.d.ts

@@ -0,0 +1,3 @@
+import { FetchResponseLike, OpenAIStreamEventLike } from '../types';
+/** Fetch Response (text/event-stream) → AsyncIterable of stream events. Handles [DONE], errors; 4xx/5xx yield error. */
+export declare function fetchResponseToStreamEvents(response: FetchResponseLike): AsyncIterable<OpenAIStreamEventLike>;

package/dist/adapters/openai/helpers/fetchResponseToStreamEvents.js

@@ -0,0 +1,64 @@
+import { __asyncGenerator, __await } from "tslib";
+const SSE_DATA_PREFIX = 'data: ';
+function parseSSELine(line) {
+    try {
+        return JSON.parse(line.slice(SSE_DATA_PREFIX.length));
+    }
+    catch (_a) {
+        return null;
+    }
+}
+/** Fetch Response (text/event-stream) → AsyncIterable of stream events. Handles [DONE], errors; 4xx/5xx yield error. */
+export function fetchResponseToStreamEvents(response) {
+    return __asyncGenerator(this, arguments, function* fetchResponseToStreamEvents_1() {
+        var _a, _b;
+        if (response.ok === false) {
+            const message = response.statusText || (response.status ? `HTTP ${response.status}` : 'HTTP error');
+            yield yield __await({ type: 'error', error: message });
+            return yield __await(void 0);
+        }
+        const reader = (_a = response.body) === null || _a === void 0 ? void 0 : _a.getReader();
+        if (!reader) {
+            return yield __await(void 0);
+        }
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = yield __await(reader.read());
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = (_b = lines.pop()) !== null && _b !== void 0 ? _b : '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed === `${SSE_DATA_PREFIX}[DONE]`) {
+                        yield yield __await({ type: 'response.done' });
+                        continue;
+                    }
+                    if (!trimmed.startsWith(SSE_DATA_PREFIX)) {
+                        continue;
+                    }
+                    const parsed = parseSSELine(trimmed);
+                    if (!parsed) {
+                        continue;
+                    }
+                    if (parsed.error) {
+                        yield yield __await({
+                            type: 'error',
+                            error: parsed.error,
+                        });
+                        return yield __await(void 0);
+                    }
+                    yield yield __await(parsed);
+                }
+            }
+            yield yield __await({ type: 'response.done' });
+        }
+        finally {
+            reader.releaseLock();
+        }
+    });
+}

package/dist/adapters/openai/helpers/getStreamErrorMessage.d.ts

@@ -0,0 +1 @@
+export declare function getStreamErrorMessage(event: Record<string, unknown>): string;

package/dist/adapters/openai/helpers/getStreamErrorMessage.js

@@ -0,0 +1,12 @@
+export function getStreamErrorMessage(event) {
+    var _a, _b;
+    if (typeof event.error === 'string')
+        return event.error;
+    const dataError = (_a = event.data) === null || _a === void 0 ? void 0 : _a.error;
+    if (dataError)
+        return dataError;
+    const message = (_b = event.error) === null || _b === void 0 ? void 0 : _b.message;
+    if (message)
+        return message;
+    return 'Stream error';
+}

package/dist/adapters/openai/helpers/getStreamEventContentUpdate.d.ts

@@ -0,0 +1,41 @@
+import type { TToolStatus } from '../../../types';
+import { OpenAIStreamEventLike } from '../types/openAiTypes';
+export type StreamEventTextDelta = {
+    kind: 'text_delta';
+    delta: string;
+};
+export type StreamEventToolAdd = {
+    kind: 'tool_add';
+    id: string;
+    toolName: string;
+    serverLabel?: string;
+    /** Initial status; use 'waitingConfirmation' for mcp_approval_request, 'waitingSubmission' if API defines such. Default 'loading'. */
+    status?: TToolStatus;
+    /** Optional payload to show in tool card (e.g. approval request arguments). */
+    headerContent?: string;
+};
+export type StreamEventToolUpdate = {
+    kind: 'tool_update';
+    item_id: string;
+    status: TToolStatus;
+    toolName?: string;
+    output?: string;
+    error?: string;
+};
+export type StreamEventThinkingAdd = {
+    kind: 'thinking_add';
+    item_id: string;
+};
+export type StreamEventThinkingDelta = {
+    kind: 'thinking_delta';
+    item_id: string;
+    delta: string;
+};
+export type StreamEventThinkingDone = {
+    kind: 'thinking_done';
+    item_id: string;
+    text: string;
+};
+export type StreamEventContentUpdate = StreamEventTextDelta | StreamEventToolAdd | StreamEventToolUpdate | StreamEventThinkingAdd | StreamEventThinkingDelta | StreamEventThinkingDone;
+/** Stream event → content update (text delta, tool add/update, thinking add/delta/done) or null. */
+export declare function getStreamEventContentUpdate(event: OpenAIStreamEventLike | null | undefined): StreamEventContentUpdate | null;