@fencyai/js 0.1.106 → 0.1.108

package/lib/openapi/stream/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/{index.d.ts → stream/index.d.ts}

@@ -4,22 +4,12 @@ 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';

package/lib/openapi/{index.js → stream/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 → stream/models}/StreamDto.d.ts

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

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

@@ -0,0 +1,24 @@
+import type { AgentTaskProgressItemUpdatedEventDto } from '../models/AgentTaskProgressItemUpdatedEventDto';
+import type { ChatCompletionStreamCompletedEventDto } from '../models/ChatCompletionStreamCompletedEventDto';
+import type { FileSearchIndexReadyEventDto } from '../models/FileSearchIndexReadyEventDto';
+import type { FileTextContentReadyEventDto } from '../models/FileTextContentReadyEventDto';
+import type { FileUploadCompletedEventDto } from '../models/FileUploadCompletedEventDto';
+import type { NewChatCompletionStreamChunkEventDto } from '../models/NewChatCompletionStreamChunkEventDto';
+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 | NewChatCompletionStreamChunkEventDto | ChatCompletionStreamCompletedEventDto | FileUploadCompletedEventDto | FileTextContentReadyEventDto | FileSearchIndexReadyEventDto | AgentTaskProgressItemUpdatedEventDto)>;
+}

package/lib/openapi/stream/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/stream/streams',
+        });
+    }
+    /**
+     * Get pub types
+     * @returns any OK
+     * @throws ApiError
+     */
+    static getPubTypes() {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/pub/stream/types',
+        });
+    }
+}

package/lib/types/AgentTask.d.ts

@@ -1,4 +1,4 @@
-import { AgentTaskStatusDto } from "../openapi";
+import { AgentTaskStatusDto } from "../openapi/client";
 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.104';
+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.106",
+  "version": "0.1.108",
   "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/client/swagger.json --output ./src/openapi/client && openapi --input http://localhost:8080/pub/stream/swagger.json --output ./src/openapi/stream"
   },
   "devDependencies": {
     "@types/jest": "^29.5.11",
@@ -42,5 +42,5 @@
     "ts-jest": "^29.1.1",
     "typescript": "^5.3.3"
   },
-  "gitHead": "e516e654cc331c80fb151ff035b29796ac736b26"
+  "gitHead": "b6e2b8dfa4bb130b0f57dc2d4decbb08c5f91850"
 }

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/models/ListMemoryTypesResponse.d.ts

@@ -1,6 +0,0 @@
-import type { PaginationDto } from './PaginationDto';
-import type { PubMemoryTypeDto } from './PubMemoryTypeDto';
-export type ListMemoryTypesResponse = {
-    items: Array<PubMemoryTypeDto>;
-    pagination: PaginationDto;
-};

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

@@ -1,4 +0,0 @@
-export type PaginationDto = {
-    previousPageToken?: string | null;
-    nextPageToken?: string | null;
-};

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

@@ -1,5 +0,0 @@
-export type PubMemoryDto = {
-    id: string;
-    createdAt: string;
-    title?: string | null;
-};

package/lib/openapi/models/PubMemoryDto.js

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

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

@@ -1,5 +0,0 @@
-export type PubMemoryTypeDto = {
-    id: string;
-    createdAt: string;
-    name: string;
-};

package/lib/openapi/models/PubMemoryTypeDto.js

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

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

@@ -1,4 +0,0 @@
-export type PubSearchMemoriesRequest = {
-    title?: string | null;
-    memoryTypeId?: string | null;
-};

package/lib/openapi/models/PubSearchMemoriesRequest.js

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

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

@@ -1,4 +0,0 @@
-import type { PubMemoryDto } from './PubMemoryDto';
-export type PubSearchMemoriesResponse = {
-    items: Array<PubMemoryDto>;
-};

package/lib/openapi/models/PubSearchMemoriesResponse.js

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

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

@@ -1,63 +0,0 @@
-import type { AgentTaskProgressItemUpdatedEventDto } from '../models/AgentTaskProgressItemUpdatedEventDto';
-import type { ChatCompletionStreamCompletedEventDto } from '../models/ChatCompletionStreamCompletedEventDto';
-import type { FileSearchIndexReadyEventDto } from '../models/FileSearchIndexReadyEventDto';
-import type { FileTextContentReadyEventDto } from '../models/FileTextContentReadyEventDto';
-import type { FileUploadCompletedEventDto } from '../models/FileUploadCompletedEventDto';
-import type { ListMemoryTypesResponse } from '../models/ListMemoryTypesResponse';
-import type { NewChatCompletionStreamChunkEventDto } from '../models/NewChatCompletionStreamChunkEventDto';
-import type { PubAgentTaskDto } from '../models/PubAgentTaskDto';
-import type { PubCreateAgentTaskRequest } from '../models/PubCreateAgentTaskRequest';
-import type { PubCreateFileDownloadLinkResponse } from '../models/PubCreateFileDownloadLinkResponse';
-import type { PubSearchMemoriesRequest } from '../models/PubSearchMemoriesRequest';
-import type { PubSearchMemoriesResponse } from '../models/PubSearchMemoriesResponse';
-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 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>;
-    /**
-     * Search Memories
-     * @param requestBody
-     * @param nextPageToken
-     * @param previousPageToken
-     * @param limit
-     * @returns PubSearchMemoriesResponse OK
-     * @throws ApiError
-     */
-    static searchMemories(requestBody: PubSearchMemoriesRequest, nextPageToken?: string, previousPageToken?: string, limit?: number): CancelablePromise<PubSearchMemoriesResponse>;
-    /**
-     * List Memory Types
-     * @param nextPageToken
-     * @param previousPageToken
-     * @param limit
-     * @returns ListMemoryTypesResponse OK
-     * @throws ApiError
-     */
-    static listMemoryTypes(nextPageToken?: string, previousPageToken?: string, limit?: number): CancelablePromise<ListMemoryTypesResponse>;
-    /**
-     * 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 | NewChatCompletionStreamChunkEventDto | ChatCompletionStreamCompletedEventDto | FileUploadCompletedEventDto | FileTextContentReadyEventDto | FileSearchIndexReadyEventDto | AgentTaskProgressItemUpdatedEventDto)>;
-}