@fencyai/js 0.1.106 → 0.1.108

package/lib/api/createAgentTask.d.ts

@@ -4,5 +4,6 @@ export declare function createAgentTask(params: {
     pk: string;
     request: CreateAgentTaskRequest;
     baseUrl: string;
-    clientSecret: string;
+    clientToken: string;
+    streamToken: string;
 }): Promise<CreateAgentTaskResponse>;

package/lib/api/createAgentTask.js

@@ -1,17 +1,17 @@
-import { OpenAPI, PubService } from '../openapi';
+import { OpenAPI, PubService } from '../openapi/client';
 import { getPackageVersion } from '../utils/version';
 export async function createAgentTask(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,
+            'X-Fency-Publishable-Key': params.pk,
+            'X-Fency-Client-Token': params.clientToken,
+            'X-Fency-Stream-Token': params.streamToken,
         };
         const response = await PubService.createAgentTask({
             queryText: params.request.queryText,
-            streamId: params.request.streamId,
             jsonSchema: params.request.jsonSchema,
             todos: params.request.todos ?? [],
         });

package/lib/api/createFileDownloadLink.d.ts

@@ -2,7 +2,8 @@ import { CreateFileDownloadLinkRequest } from '../types/CreateFileDownloadLinkRe
 import { CreateFileDownloadLinkResponse } from '../types/CreateFileDownloadLinkResponse';
 export declare function createFileDownloadLink(params: {
     pk: string;
-    clientSecret: string;
+    clientToken: string;
+    streamToken: string;
     request: CreateFileDownloadLinkRequest;
     baseUrl: string;
 }): Promise<CreateFileDownloadLinkResponse>;

package/lib/api/createFileDownloadLink.js

@@ -4,7 +4,8 @@ export async function createFileDownloadLink(params) {
         const response = await createFileDownloadLinkApi({
             baseUrl: params.baseUrl,
             pk: params.pk,
-            clientSecret: params.clientSecret,
+            clientToken: params.clientToken,
+            streamToken: params.streamToken,
             fileId: params.request.fileId,
         });
         return {
@@ -21,9 +22,10 @@ async function createFileDownloadLinkApi(params) {
         method: 'POST',
         headers: {
             'Content-Type': 'application/json',
-            Authorization: `Bearer ${params.pk}`,
             'X-Fency-Sdk-Version': getPackageVersion(),
-            'X-Fency-Client-Secret': params.clientSecret,
+            'X-Fency-Publishable-Key': params.pk,
+            'X-Fency-Client-Token': params.clientToken,
+            'X-Fency-Stream-Token': params.streamToken,
         },
     });
     if (!response.ok) {

package/lib/api/createStream.d.ts

@@ -2,5 +2,5 @@ import { CreateStreamResponse } from '../types/CreateStreamResponse';
 export declare function createStream(params: {
     pk: string;
     baseUrl: string;
-    clientSecret: string;
+    clientToken: string;
 }): Promise<CreateStreamResponse>;

package/lib/api/createStream.js

@@ -1,20 +1,21 @@
-import { OpenAPI, PubService } from '../openapi';
+import { OpenAPI } from '../openapi/stream';
 import { getPackageVersion } from '../utils/version';
 export async function createStream(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,
+            'X-Fency-Publishable-Key': params.pk,
+            'X-Fency-Client-Token': params.clientToken,
         };
-        const response = await PubService.createStream();
+        const response = await createStreamApi(params);
         return {
             type: 'success',
             stream: {
                 id: response.id,
                 createdAt: response.createdAt,
+                token: response.token,
             },
         };
     }
@@ -28,3 +29,18 @@ export async function createStream(params) {
         };
     }
 }
+const createStreamApi = async (params) => {
+    const response = await fetch(`${params.baseUrl}/pub/stream/streams`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'X-Fency-Sdk-Version': getPackageVersion(),
+            'X-Fency-Publishable-Key': params.pk,
+            'X-Fency-Client-Token': params.clientToken,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to create stream: ${response.statusText}`);
+    }
+    return response.json();
+};

package/lib/index.d.ts

@@ -1,10 +1,15 @@
 export { loadFency } from './loadFency';
-export type { FencyInstance, FencyOptions } from './types';
+export type { FencyInstance } from './types/FencyInstance';
+export type { FencyOptions } from './types/FencyOptions';
 export * from './types/index';
-export type { ChatCompletionStreamCompletedEventDto, FileTextContentReadyEventDto, FileUploadCompletedEventDto, NewChatCompletionStreamChunkEventDto, StreamNotFoundEventDto, StreamTimeoutEventDto, AgentTaskProgressItemUpdatedEventDto, PaginationDto, PubMemoryDto, PubMemoryTypeDto, } from './openapi';
-export { AgentTaskProgressItemType } from './openapi';
+export { AgentTaskProgressItemType } from './openapi/stream/models/AgentTaskProgressItemType';
+export type { AgentTaskProgressItemUpdatedEventDto } from './openapi/stream/models/AgentTaskProgressItemUpdatedEventDto';
+export type { ChatCompletionStreamCompletedEventDto } from './openapi/stream/models/ChatCompletionStreamCompletedEventDto';
+export type { FileTextContentReadyEventDto } from './openapi/stream/models/FileTextContentReadyEventDto';
+export type { FileUploadCompletedEventDto } from './openapi/stream/models/FileUploadCompletedEventDto';
+export type { NewChatCompletionStreamChunkEventDto } from './openapi/stream/models/NewChatCompletionStreamChunkEventDto';
+export type { StreamNotFoundEventDto } from './openapi/stream/models/StreamNotFoundEventDto';
+export type { StreamTimeoutEventDto } from './openapi/stream/models/StreamTimeoutEventDto';
 export { createAgentTask } from './api/createAgentTask';
 export { createStream } from './api/createStream';
-export { listMemoryTypes } from './api/listMemoryTypes';
-export { searchMemories } from './api/searchMemories';
 export { createFileDownloadLink } from './api/createFileDownloadLink';

package/lib/index.js

@@ -1,9 +1,8 @@
 export { loadFency } from './loadFency';
 export * from './types/index';
-export { AgentTaskProgressItemType } from './openapi';
+// stream event types
+export { AgentTaskProgressItemType } from './openapi/stream/models/AgentTaskProgressItemType';
 // api
 export { createAgentTask } from './api/createAgentTask';
 export { createStream } from './api/createStream';
-export { listMemoryTypes } from './api/listMemoryTypes';
-export { searchMemories } from './api/searchMemories';
 export { createFileDownloadLink } from './api/createFileDownloadLink';

package/lib/loadFency.d.ts

@@ -1,4 +1,5 @@
-import { FencyInstance, FencyOptions } from './types';
+import { FencyInstance } from './types/FencyInstance';
+import { FencyOptions } from './types/FencyOptions';
 /**
  * Loads the Fency library with the given publishable key.
  * This method should be called outside of a component's render to avoid

package/lib/openapi/client/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/client/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 → client/models}/PubCreateAgentTaskRequest.d.ts

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

package/lib/openapi/client/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/client/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/client/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/client/files/{fileId}/download-links',
+            path: {
+                'fileId': fileId,
+            },
+        });
+    }
+}

package/lib/openapi/stream/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/lib/openapi/stream/core/ApiError.js

@@ -0,0 +1,11 @@
+export class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/lib/openapi/stream/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/lib/openapi/stream/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/lib/openapi/stream/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/lib/openapi/stream/core/CancelablePromise.js

@@ -0,0 +1,111 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+export class CancelablePromise {
+    constructor(executor) {
+        _CancelablePromise_isResolved.set(this, void 0);
+        _CancelablePromise_isRejected.set(this, void 0);
+        _CancelablePromise_isCancelled.set(this, void 0);
+        _CancelablePromise_cancelHandlers.set(this, void 0);
+        _CancelablePromise_promise.set(this, void 0);
+        _CancelablePromise_resolve.set(this, void 0);
+        _CancelablePromise_reject.set(this, void 0);
+        __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
+        __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
+            const onResolve = (value) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_resolve, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_resolve, "f").call(this, value);
+            };
+            const onReject = (reason) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+                    __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f"),
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f"),
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f"),
+            });
+            return executor(onResolve, onReject, onCancel);
+        }), "f");
+    }
+    get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
+    }
+    finally(onFinally) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
+    }
+    cancel() {
+        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
+        if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
+            try {
+                for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
+        if (__classPrivateFieldGet(this, _CancelablePromise_reject, "f"))
+            __classPrivateFieldGet(this, _CancelablePromise_reject, "f").call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}

package/lib/openapi/stream/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/lib/openapi/stream/core/OpenAPI.js

@@ -0,0 +1,11 @@
+export const OpenAPI = {
+    BASE: '',
+    VERSION: '1.0',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};

package/lib/openapi/stream/core/request.d.ts

@@ -0,0 +1,30 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare const isDefined: <T>(value: T | null | undefined) => value is Exclude<T, null | undefined>;
+export declare const isString: (value: any) => value is string;
+export declare const isStringWithValue: (value: any) => value is string;
+export declare const isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: any) => value is FormData;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, any>) => string;
+export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T>) => Promise<T | undefined>;
+export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions) => Promise<Headers>;
+export declare const getRequestBody: (options: ApiRequestOptions) => any;
+export declare const sendRequest: (config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Headers, onCancel: OnCancel) => Promise<Response>;
+export declare const getResponseHeader: (response: Response, responseHeader?: string) => string | undefined;
+export declare const getResponseBody: (response: Response) => Promise<any>;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+export {};