@fencyai/js 0.1.107 → 0.1.109

package/lib/openapi/ct/core/request.js

@@ -0,0 +1,275 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import { ApiError } from './ApiError';
+import { CancelablePromise } from './CancelablePromise';
+export const isDefined = (value) => {
+    return value !== undefined && value !== null;
+};
+export const isString = (value) => {
+    return typeof value === 'string';
+};
+export const isStringWithValue = (value) => {
+    return isString(value) && value !== '';
+};
+export const isBlob = (value) => {
+    return (typeof value === 'object' &&
+        typeof value.type === 'string' &&
+        typeof value.stream === 'function' &&
+        typeof value.arrayBuffer === 'function' &&
+        typeof value.constructor === 'function' &&
+        typeof value.constructor.name === 'string' &&
+        /^(Blob|File)$/.test(value.constructor.name) &&
+        /^(Blob|File)$/.test(value[Symbol.toStringTag]));
+};
+export const isFormData = (value) => {
+    return value instanceof FormData;
+};
+export const base64 = (str) => {
+    try {
+        return btoa(str);
+    }
+    catch (err) {
+        // @ts-ignore
+        return Buffer.from(str).toString('base64');
+    }
+};
+export const getQueryString = (params) => {
+    const qs = [];
+    const append = (key, value) => {
+        qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    };
+    const process = (key, value) => {
+        if (isDefined(value)) {
+            if (Array.isArray(value)) {
+                value.forEach(v => {
+                    process(key, v);
+                });
+            }
+            else if (typeof value === 'object') {
+                Object.entries(value).forEach(([k, v]) => {
+                    process(`${key}[${k}]`, v);
+                });
+            }
+            else {
+                append(key, value);
+            }
+        }
+    };
+    Object.entries(params).forEach(([key, value]) => {
+        process(key, value);
+    });
+    if (qs.length > 0) {
+        return `?${qs.join('&')}`;
+    }
+    return '';
+};
+const getUrl = (config, options) => {
+    const encoder = config.ENCODE_PATH || encodeURI;
+    const path = options.url
+        .replace('{api-version}', config.VERSION)
+        .replace(/{(.*?)}/g, (substring, group) => {
+        if (options.path?.hasOwnProperty(group)) {
+            return encoder(String(options.path[group]));
+        }
+        return substring;
+    });
+    const url = `${config.BASE}${path}`;
+    if (options.query) {
+        return `${url}${getQueryString(options.query)}`;
+    }
+    return url;
+};
+export const getFormData = (options) => {
+    if (options.formData) {
+        const formData = new FormData();
+        const process = (key, value) => {
+            if (isString(value) || isBlob(value)) {
+                formData.append(key, value);
+            }
+            else {
+                formData.append(key, JSON.stringify(value));
+            }
+        };
+        Object.entries(options.formData)
+            .filter(([_, value]) => isDefined(value))
+            .forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+                value.forEach(v => process(key, v));
+            }
+            else {
+                process(key, value);
+            }
+        });
+        return formData;
+    }
+    return undefined;
+};
+export const resolve = async (options, resolver) => {
+    if (typeof resolver === 'function') {
+        return resolver(options);
+    }
+    return resolver;
+};
+export const getHeaders = async (config, options) => {
+    const [token, username, password, additionalHeaders] = await Promise.all([
+        resolve(options, config.TOKEN),
+        resolve(options, config.USERNAME),
+        resolve(options, config.PASSWORD),
+        resolve(options, config.HEADERS),
+    ]);
+    const headers = Object.entries({
+        Accept: 'application/json',
+        ...additionalHeaders,
+        ...options.headers,
+    })
+        .filter(([_, value]) => isDefined(value))
+        .reduce((headers, [key, value]) => ({
+        ...headers,
+        [key]: String(value),
+    }), {});
+    if (isStringWithValue(token)) {
+        headers['Authorization'] = `Bearer ${token}`;
+    }
+    if (isStringWithValue(username) && isStringWithValue(password)) {
+        const credentials = base64(`${username}:${password}`);
+        headers['Authorization'] = `Basic ${credentials}`;
+    }
+    if (options.body !== undefined) {
+        if (options.mediaType) {
+            headers['Content-Type'] = options.mediaType;
+        }
+        else if (isBlob(options.body)) {
+            headers['Content-Type'] = options.body.type || 'application/octet-stream';
+        }
+        else if (isString(options.body)) {
+            headers['Content-Type'] = 'text/plain';
+        }
+        else if (!isFormData(options.body)) {
+            headers['Content-Type'] = 'application/json';
+        }
+    }
+    return new Headers(headers);
+};
+export const getRequestBody = (options) => {
+    if (options.body !== undefined) {
+        if (options.mediaType?.includes('/json')) {
+            return JSON.stringify(options.body);
+        }
+        else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+            return options.body;
+        }
+        else {
+            return JSON.stringify(options.body);
+        }
+    }
+    return undefined;
+};
+export const sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+    const controller = new AbortController();
+    const request = {
+        headers,
+        body: body ?? formData,
+        method: options.method,
+        signal: controller.signal,
+    };
+    if (config.WITH_CREDENTIALS) {
+        request.credentials = config.CREDENTIALS;
+    }
+    onCancel(() => controller.abort());
+    return await fetch(url, request);
+};
+export const getResponseHeader = (response, responseHeader) => {
+    if (responseHeader) {
+        const content = response.headers.get(responseHeader);
+        if (isString(content)) {
+            return content;
+        }
+    }
+    return undefined;
+};
+export const getResponseBody = async (response) => {
+    if (response.status !== 204) {
+        try {
+            const contentType = response.headers.get('Content-Type');
+            if (contentType) {
+                const jsonTypes = ['application/json', 'application/problem+json'];
+                const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));
+                if (isJSON) {
+                    return await response.json();
+                }
+                else {
+                    return await response.text();
+                }
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    return undefined;
+};
+export const catchErrorCodes = (options, result) => {
+    const errors = {
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        ...options.errors,
+    };
+    const error = errors[result.status];
+    if (error) {
+        throw new ApiError(options, result, error);
+    }
+    if (!result.ok) {
+        const errorStatus = result.status ?? 'unknown';
+        const errorStatusText = result.statusText ?? 'unknown';
+        const errorBody = (() => {
+            try {
+                return JSON.stringify(result.body, null, 2);
+            }
+            catch (e) {
+                return undefined;
+            }
+        })();
+        throw new ApiError(options, result, `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`);
+    }
+};
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export const request = (config, options) => {
+    return new CancelablePromise(async (resolve, reject, onCancel) => {
+        try {
+            const url = getUrl(config, options);
+            const formData = getFormData(options);
+            const body = getRequestBody(options);
+            const headers = await getHeaders(config, options);
+            if (!onCancel.isCancelled) {
+                const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+                const responseBody = await getResponseBody(response);
+                const responseHeader = getResponseHeader(response, options.responseHeader);
+                const result = {
+                    url,
+                    ok: response.ok,
+                    status: response.status,
+                    statusText: response.statusText,
+                    body: responseHeader ?? responseBody,
+                };
+                catchErrorCodes(options, result);
+                resolve(result.body);
+            }
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};

package/lib/openapi/ct/index.d.ts

@@ -0,0 +1,12 @@
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI } from './core/OpenAPI';
+export type { OpenAPIConfig } from './core/OpenAPI';
+export { AgentTaskProgressItemType } from './models/AgentTaskProgressItemType';
+export type { AgentTaskProgressItemUpdatedEventDto } from './models/AgentTaskProgressItemUpdatedEventDto';
+export { ApiDtoType } from './models/ApiDtoType';
+export type { StreamDto } from './models/StreamDto';
+export { StreamEventType } from './models/StreamEventType';
+export type { StreamNotFoundEventDto } from './models/StreamNotFoundEventDto';
+export type { StreamTimeoutEventDto } from './models/StreamTimeoutEventDto';
+export { PubService } from './services/PubService';

package/lib/openapi/{index.js → ct/index.js}

@@ -6,7 +6,6 @@ export { ApiError } from './core/ApiError';
 export { CancelablePromise, CancelError } from './core/CancelablePromise';
 export { OpenAPI } from './core/OpenAPI';
 export { AgentTaskProgressItemType } from './models/AgentTaskProgressItemType';
-export { AgentTaskStatusDto } from './models/AgentTaskStatusDto';
 export { ApiDtoType } from './models/ApiDtoType';
 export { StreamEventType } from './models/StreamEventType';
 export { PubService } from './services/PubService';

package/lib/openapi/{models → ct/models}/StreamDto.d.ts

@@ -3,4 +3,5 @@ export type StreamDto = {
     id: string;
     createdAt: string;
     type: ApiDtoType;
+    token: string;
 };

package/lib/openapi/ct/models/StreamEventType.d.ts

@@ -0,0 +1,6 @@
+export declare enum StreamEventType {
+    STREAM_TIMEOUT = "StreamTimeout",
+    STREAM_NOT_FOUND = "StreamNotFound",
+    STREAM_UNAUTHORIZED = "StreamUnauthorized",
+    AGENT_TASK_PROGRESS_ITEM_UPDATED = "AgentTaskProgressItemUpdated"
+}

package/lib/openapi/ct/models/StreamEventType.js

@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export var StreamEventType;
+(function (StreamEventType) {
+    StreamEventType["STREAM_TIMEOUT"] = "StreamTimeout";
+    StreamEventType["STREAM_NOT_FOUND"] = "StreamNotFound";
+    StreamEventType["STREAM_UNAUTHORIZED"] = "StreamUnauthorized";
+    StreamEventType["AGENT_TASK_PROGRESS_ITEM_UPDATED"] = "AgentTaskProgressItemUpdated";
+})(StreamEventType || (StreamEventType = {}));

package/lib/openapi/ct/services/PubService.d.ts

@@ -0,0 +1,19 @@
+import type { AgentTaskProgressItemUpdatedEventDto } from '../models/AgentTaskProgressItemUpdatedEventDto';
+import type { StreamDto } from '../models/StreamDto';
+import type { StreamNotFoundEventDto } from '../models/StreamNotFoundEventDto';
+import type { StreamTimeoutEventDto } from '../models/StreamTimeoutEventDto';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class PubService {
+    /**
+     * Create Chat Completion Stream
+     * @returns StreamDto Created
+     * @throws ApiError
+     */
+    static createStream(): CancelablePromise<StreamDto>;
+    /**
+     * Get pub types
+     * @returns any OK
+     * @throws ApiError
+     */
+    static getPubTypes(): CancelablePromise<(StreamTimeoutEventDto | StreamNotFoundEventDto | AgentTaskProgressItemUpdatedEventDto)>;
+}

package/lib/openapi/ct/services/PubService.js

@@ -0,0 +1,26 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PubService {
+    /**
+     * Create Chat Completion Stream
+     * @returns StreamDto Created
+     * @throws ApiError
+     */
+    static createStream() {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pub/ct/streams',
+        });
+    }
+    /**
+     * Get pub types
+     * @returns any OK
+     * @throws ApiError
+     */
+    static getPubTypes() {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pub/ct/types',
+        });
+    }
+}

package/lib/openapi/ct-st/index.d.ts

@@ -0,0 +1,9 @@
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI } from './core/OpenAPI';
+export type { OpenAPIConfig } from './core/OpenAPI';
+export { AgentTaskStatusDto } from './models/AgentTaskStatusDto';
+export type { PubAgentTaskDto } from './models/PubAgentTaskDto';
+export type { PubCreateAgentTaskRequest } from './models/PubCreateAgentTaskRequest';
+export type { PubCreateFileDownloadLinkResponse } from './models/PubCreateFileDownloadLinkResponse';
+export { PubService } from './services/PubService';

package/lib/openapi/ct-st/index.js

@@ -0,0 +1,9 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export { ApiError } from './core/ApiError';
+export { CancelablePromise, CancelError } from './core/CancelablePromise';
+export { OpenAPI } from './core/OpenAPI';
+export { AgentTaskStatusDto } from './models/AgentTaskStatusDto';
+export { PubService } from './services/PubService';

package/lib/openapi/{models → ct-st/models}/PubCreateAgentTaskRequest.d.ts

@@ -1,6 +1,5 @@
 export type PubCreateAgentTaskRequest = {
     queryText: string;
-    streamId: string;
     jsonSchema?: string | null;
     todos: Array<string>;
 };

package/lib/openapi/ct-st/services/PubService.d.ts

@@ -0,0 +1,20 @@
+import type { PubAgentTaskDto } from '../models/PubAgentTaskDto';
+import type { PubCreateAgentTaskRequest } from '../models/PubCreateAgentTaskRequest';
+import type { PubCreateFileDownloadLinkResponse } from '../models/PubCreateFileDownloadLinkResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+export declare class PubService {
+    /**
+     * Create AgentTask
+     * @param requestBody
+     * @returns PubAgentTaskDto Created
+     * @throws ApiError
+     */
+    static createAgentTask(requestBody: PubCreateAgentTaskRequest): CancelablePromise<PubAgentTaskDto>;
+    /**
+     * Create File Download Link
+     * @param fileId
+     * @returns PubCreateFileDownloadLinkResponse OK
+     * @throws ApiError
+     */
+    static createFileDownloadLink(fileId: string): CancelablePromise<PubCreateFileDownloadLinkResponse>;
+}

package/lib/openapi/ct-st/services/PubService.js

@@ -0,0 +1,33 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PubService {
+    /**
+     * Create AgentTask
+     * @param requestBody
+     * @returns PubAgentTaskDto Created
+     * @throws ApiError
+     */
+    static createAgentTask(requestBody) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pub/ct-st/agent-tasks',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Create File Download Link
+     * @param fileId
+     * @returns PubCreateFileDownloadLinkResponse OK
+     * @throws ApiError
+     */
+    static createFileDownloadLink(fileId) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pub/ct-st/files/{fileId}/download-links',
+            path: {
+                'fileId': fileId,
+            },
+        });
+    }
+}

package/lib/types/AgentTask.d.ts

@@ -1,4 +1,4 @@
-import { AgentTaskStatusDto } from "../openapi";
+import { AgentTaskStatusDto } from "../openapi/ct-st";
 export type AgentTask = {
     id: string;
     status: AgentTaskStatusDto;

package/lib/types/Stream.d.ts

@@ -1,5 +1,6 @@
 export interface Stream {
     id: string;
     createdAt: string;
+    token: string;
 }
 export declare const isStream: (data: any) => data is Stream;

package/lib/types/index.d.ts

@@ -1,28 +1,7 @@
-export type { AnthropicModel } from './AnthropicModel';
 export type { ApiError } from './ApiError';
-export { isAgentTask } from './AgentTask';
 export type { AgentTask } from './AgentTask';
-export { isChatCompletion } from './ChatCompletion';
-export type { ChatCompletion } from './ChatCompletion';
-export type { ChatCompletionMessage } from './ChatCompletionMessage';
-export type { ClaudeChatCompletionMessage } from './ClaudeChatCompletionMessage';
 export type { CreateAgentTaskRequest } from './CreateAgentTaskRequest';
 export type { CreateAgentTaskResponse } from './CreateAgentTaskResponse';
-export type { CreateChatCompletionRequest } from './CreateChatCompletionRequest';
-export type { CreateClaudeChatCompletionRequestParams } from './CreateClaudeChatCompletionRequestParams';
-export type { CreateGeminiChatCompletionRequestParams } from './CreateGeminiChatCompletionRequestParams';
-export type { CreateOpenAiChatCompletionRequestParams } from './CreateOpenAiChatCompletionRequestParams';
 export type { CreateStreamResponse } from './CreateStreamResponse';
-export type { GeminiChatCompletionMessage } from './GeminiChatCompletionMessage';
-export type { GeminiModel } from './GeminiModel';
-export type { OpenAiModel } from './OpenAiModel';
-export type { S3PostRequest } from './S3PostRequest';
-export type { Stream } from './Stream';
-export type { ListMemoryTypesResponse } from './ListMemoryTypesResponse';
-export type { CreateChatCompletionResponse } from './CreateChatCompletionResponse';
-export type { FencyInstance } from './FencyInstance';
-export type { FencyOptions } from './FencyOptions';
-export type { SearchMemoriesResponse } from './SearchMemoriesResponse';
-export type { SearchMemoriesRequest } from './SearchMemoriesRequest';
-export type { CreateFileDownloadLinkRequest } from './CreateFileDownloadLinkRequest';
 export type { CreateFileDownloadLinkResponse } from './CreateFileDownloadLinkResponse';
+export type { Stream } from './Stream';

package/lib/types/index.js

@@ -1,2 +1 @@
-export { isAgentTask } from './AgentTask';
-export { isChatCompletion } from './ChatCompletion';
+export {};

package/lib/utils/version.js

@@ -1,7 +1,7 @@
 // Browser-compatible version utility
 // The version is set at build time and can be overridden if needed
 // Build-time version constant - this should be updated during the build process
-const SDK_VERSION = '0.1.105';
+const SDK_VERSION = '0.1.107';
 // Allow runtime override if needed
 let versionOverride = null;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fencyai/js",
-  "version": "0.1.107",
+  "version": "0.1.109",
   "description": "> TODO: description",
   "author": "staklau <steinaageklaussen@gmail.com>",
   "homepage": "",
@@ -32,7 +32,7 @@
     "test:watch": "jest --watch",
     "dev": "tsc --watch",
     "prepublishOnly": "npm run build",
-    "codegen": "openapi --input http://localhost:8080/v1/pub/swagger.json --output ./src/openapi"
+    "codegen": "openapi --input http://localhost:8080/pub/ct-st/swagger.json --output ./src/openapi/ct-st && openapi --input http://localhost:8080/pub/ct/swagger.json --output ./src/openapi/ct"
   },
   "devDependencies": {
     "@types/jest": "^29.5.11",
@@ -42,5 +42,5 @@
     "ts-jest": "^29.1.1",
     "typescript": "^5.3.3"
   },
-  "gitHead": "2145bf7e2f4efa0c03c5b588347fec26adc09e7e"
+  "gitHead": "2663038df613dc32b2ba59c8ef2c0bf6c0dd767a"
 }

package/lib/api/listMemoryTypes.d.ts

@@ -1,6 +0,0 @@
-import { ListMemoryTypesResponse } from '../types';
-export declare function listMemoryTypes(params: {
-    pk: string;
-    clientSecret: string;
-    baseUrl: string;
-}): Promise<ListMemoryTypesResponse>;

package/lib/api/listMemoryTypes.js

@@ -1,28 +0,0 @@
-import { OpenAPI, PubService } from '../openapi';
-import { getPackageVersion } from '../utils/version';
-export async function listMemoryTypes(params) {
-    try {
-        OpenAPI.BASE = params.baseUrl;
-        OpenAPI.HEADERS = {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${params.pk}`,
-            'X-Fency-Sdk-Version': getPackageVersion(),
-            'X-Fency-Client-Secret': params.clientSecret,
-        };
-        const response = await PubService.listMemoryTypes();
-        return {
-            type: 'success',
-            items: response.items,
-            pagination: response.pagination,
-        };
-    }
-    catch (error) {
-        return {
-            type: 'error',
-            error: {
-                code: 'UnknownError',
-                message: `Unknown error!\n${error ? `Error: ${error}\n` : ''}`.trim(),
-            },
-        };
-    }
-}

package/lib/api/searchMemories.d.ts

@@ -1,8 +0,0 @@
-import { SearchMemoriesRequest } from '../types/SearchMemoriesRequest';
-import { SearchMemoriesResponse } from '../types/SearchMemoriesResponse';
-export declare function searchMemories(params: {
-    pk: string;
-    clientSecret: string;
-    request: SearchMemoriesRequest;
-    baseUrl: string;
-}): Promise<SearchMemoriesResponse>;

package/lib/api/searchMemories.js

@@ -1,27 +0,0 @@
-import { OpenAPI, PubService } from '../openapi';
-import { getPackageVersion } from '../utils/version';
-export async function searchMemories(params) {
-    try {
-        OpenAPI.BASE = params.baseUrl;
-        OpenAPI.HEADERS = {
-            'Content-Type': 'application/json',
-            Authorization: `Bearer ${params.pk}`,
-            'X-Fency-Sdk-Version': getPackageVersion(),
-            'X-Fency-Client-Secret': params.clientSecret,
-        };
-        const response = await PubService.searchMemories(params.request);
-        return {
-            type: 'success',
-            items: response.items,
-        };
-    }
-    catch (error) {
-        return {
-            type: 'error',
-            error: {
-                code: 'UnknownError',
-                message: `Unknown error!\n${error ? `Error: ${error}\n` : ''}`.trim(),
-            },
-        };
-    }
-}

package/lib/openapi/index.d.ts

@@ -1,27 +0,0 @@
-export { ApiError } from './core/ApiError';
-export { CancelablePromise, CancelError } from './core/CancelablePromise';
-export { OpenAPI } from './core/OpenAPI';
-export type { OpenAPIConfig } from './core/OpenAPI';
-export { AgentTaskProgressItemType } from './models/AgentTaskProgressItemType';
-export type { AgentTaskProgressItemUpdatedEventDto } from './models/AgentTaskProgressItemUpdatedEventDto';
-export { AgentTaskStatusDto } from './models/AgentTaskStatusDto';
-export { ApiDtoType } from './models/ApiDtoType';
-export type { ChatCompletionStreamCompletedEventDto } from './models/ChatCompletionStreamCompletedEventDto';
-export type { FileSearchIndexReadyEventDto } from './models/FileSearchIndexReadyEventDto';
-export type { FileTextContentReadyEventDto } from './models/FileTextContentReadyEventDto';
-export type { FileUploadCompletedEventDto } from './models/FileUploadCompletedEventDto';
-export type { ListMemoryTypesResponse } from './models/ListMemoryTypesResponse';
-export type { NewChatCompletionStreamChunkEventDto } from './models/NewChatCompletionStreamChunkEventDto';
-export type { PaginationDto } from './models/PaginationDto';
-export type { PubAgentTaskDto } from './models/PubAgentTaskDto';
-export type { PubCreateAgentTaskRequest } from './models/PubCreateAgentTaskRequest';
-export type { PubCreateFileDownloadLinkResponse } from './models/PubCreateFileDownloadLinkResponse';
-export type { PubMemoryDto } from './models/PubMemoryDto';
-export type { PubMemoryTypeDto } from './models/PubMemoryTypeDto';
-export type { PubSearchMemoriesRequest } from './models/PubSearchMemoriesRequest';
-export type { PubSearchMemoriesResponse } from './models/PubSearchMemoriesResponse';
-export type { StreamDto } from './models/StreamDto';
-export { StreamEventType } from './models/StreamEventType';
-export type { StreamNotFoundEventDto } from './models/StreamNotFoundEventDto';
-export type { StreamTimeoutEventDto } from './models/StreamTimeoutEventDto';
-export { PubService } from './services/PubService';

package/lib/openapi/models/ChatCompletionStreamCompletedEventDto.d.ts

@@ -1,7 +0,0 @@
-import type { StreamEventType } from './StreamEventType';
-export type ChatCompletionStreamCompletedEventDto = {
-    type: StreamEventType;
-    streamId: string;
-    chatCompletionId: string;
-    timestamp: string;
-};

package/lib/openapi/models/FileSearchIndexReadyEventDto.d.ts

@@ -1,7 +0,0 @@
-import type { StreamEventType } from './StreamEventType';
-export type FileSearchIndexReadyEventDto = {
-    type: StreamEventType;
-    streamId: string;
-    fileId: string;
-    timestamp: string;
-};