@appconda/sdk 1.0.556 → 1.0.558

package/dist/EmploidClient.d.ts

@@ -0,0 +1,52 @@
+export interface PredictionData {
+    chatflowId: string;
+    question: string;
+    overrideConfig?: Record<string, any>;
+    chatId?: string;
+    streaming?: boolean;
+    history?: IMessage[];
+    uploads?: IFileUpload[];
+    leadEmail?: string;
+    action?: IAction;
+}
+interface IAction {
+    id?: string;
+    elements?: Array<{
+        type: string;
+        label: string;
+    }>;
+    mapping?: {
+        approve: string;
+        reject: string;
+        toolCalls: any[];
+    };
+}
+interface IFileUpload {
+    data?: string;
+    type: string;
+    name: string;
+    mime: string;
+}
+interface IMessage {
+    message: string;
+    type: MessageType;
+    role?: MessageType;
+    content?: string;
+}
+type MessageType = 'apiMessage' | 'userMessage';
+export interface StreamResponse {
+    event: string;
+    data: string;
+}
+interface EmploidClientOptions {
+    baseUrl?: string;
+    apiKey?: string;
+}
+type PredictionResponse<T extends PredictionData> = T['streaming'] extends true ? AsyncGenerator<StreamResponse, void, unknown> : Record<string, any>;
+export default class EmploidClient {
+    private baseUrl;
+    private apiKey;
+    constructor(options?: EmploidClientOptions);
+    createPrediction<T extends PredictionData>(data: T): Promise<PredictionResponse<T>>;
+}
+export {};

package/dist/EmploidClient.js

@@ -0,0 +1,78 @@
+export default class EmploidClient {
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || 'http://localhost:3000';
+        this.apiKey = options.apiKey || '';
+    }
+    // Method to create a new prediction and handle streaming response
+    async createPrediction(data) {
+        const { chatflowId, streaming } = data;
+        // Check if chatflow is available to stream
+        const chatFlowStreamingUrl = `${this.baseUrl}/api/v1/chatflows-streaming/${chatflowId}`;
+        const resp = await fetch(chatFlowStreamingUrl, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const chatFlowStreamingData = await resp.json();
+        const isChatFlowAvailableToStream = chatFlowStreamingData.isStreaming || false;
+        const predictionUrl = `${this.baseUrl}/api/v1/prediction/${chatflowId}`;
+        const options = {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(data),
+        };
+        if (this.apiKey) {
+            options.headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        if (isChatFlowAvailableToStream && streaming) {
+            return {
+                async *[Symbol.asyncIterator]() {
+                    const response = await fetch(predictionUrl, options);
+                    if (!response.ok) {
+                        throw new Error(`HTTP error! status: ${response.status}`);
+                    }
+                    //@ts-ignore
+                    const reader = response.body.getReader();
+                    const decoder = new TextDecoder();
+                    let buffer = '';
+                    try {
+                        while (true) {
+                            const { done, value } = await reader.read();
+                            if (done)
+                                break;
+                            buffer += decoder.decode(value, { stream: true });
+                            const lines = buffer.split('\n');
+                            buffer = lines.pop() || '';
+                            for (const line of lines) {
+                                if (line.trim() === '')
+                                    continue;
+                                if (line.startsWith('data:')) {
+                                    const stringifiedJson = line.replace('data:', '');
+                                    const event = JSON.parse(stringifiedJson);
+                                    yield event;
+                                }
+                            }
+                        }
+                    }
+                    finally {
+                        reader.releaseLock();
+                    }
+                },
+            };
+        }
+        else {
+            try {
+                const response = await fetch(predictionUrl, options);
+                const resp = await response.json();
+                return resp;
+            }
+            catch (error) {
+                throw new Error('Error creating prediction');
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"EmploidClient.js","sourceRoot":"","sources":["../src/EmploidClient.ts"],"names":[],"mappings":"AAuDA,MAAM,CAAC,OAAO,OAAO,aAAa;IAI9B,YAAY,UAAgC,EAAE;QAC1C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,uBAAuB,CAAC;QAC1D,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC;IACvC,CAAC;IAED,kEAAkE;IAClE,KAAK,CAAC,gBAAgB,CAClB,IAAO;QAEP,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;QAEvC,2CAA2C;QAC3C,MAAM,oBAAoB,GAAG,GAAG,IAAI,CAAC,OAAO,+BAA+B,UAAU,EAAE,CAAC;QACxF,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,oBAAoB,EAAE;YAC3C,MAAM,EAAE,KAAK;YACb,OAAO,EAAE;gBACL,cAAc,EAAE,kBAAkB;aACrC;SACJ,CAAC,CAAC;QAEH,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QAChD,MAAM,2BAA2B,GAC7B,qBAAqB,CAAC,WAAW,IAAI,KAAK,CAAC;QAE/C,MAAM,aAAa,GAAG,GAAG,IAAI,CAAC,OAAO,sBAAsB,UAAU,EAAE,CAAC;QAExE,MAAM,OAAO,GAAQ;YACjB,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACL,cAAc,EAAE,kBAAkB;aACrC;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SAC7B,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACd,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,GAAG,UAAU,IAAI,CAAC,MAAM,EAAE,CAAC;QAC/D,CAAC;QAED,IAAI,2BAA2B,IAAI,SAAS,EAAE,CAAC;YAC3C,OAAO;gBACH,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC;oBACzB,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;oBAErD,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;wBACf,MAAM,IAAI,KAAK,CACX,uBAAuB,QAAQ,CAAC,MAAM,EAAE,CAC3C,CAAC;oBACN,CAAC;oBAED,YAAY;oBACZ,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;oBACzC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;oBAClC,IAAI,MAAM,GAAG,EAAE,CAAC;oBAEhB,IAAI,CAAC;wBACD,OAAO,IAAI,EAAE,CAAC;4BACV,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;4BAC5C,IAAI,IAAI;gCAAE,MAAM;4BAEhB,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;4BAClD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;4BACjC,MAAM,GAAG,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;4BAE3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gCACvB,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE;oCAAE,SAAS;gCACjC,IAAI,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;oCAC3B,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAChC,OAAO,EACP,EAAE,CACL,CAAC;oCACF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;oCAC1C,MAAM,KAAK,CAAC;gCAChB,CAAC;4BACL,CAAC;wBACL,CAAC;oBACL,CAAC;4BAAS,CAAC;wBACP,MAAM,CAAC,WAAW,EAAE,CAAC;oBACzB,CAAC;gBACL,CAAC;aACyC,CAAC;QACnD,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC;gBACD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC;gBACrD,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;gBACnC,OAAO,IAAsC,CAAC;YAClD,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;YACjD,CAAC;QACL,CAAC;IACL,CAAC;CACJ","sourcesContent":["export interface PredictionData {\n    chatflowId: string;\n    question: string;\n    overrideConfig?: Record<string, any>;\n    chatId?: string;\n    streaming?: boolean;\n    history?: IMessage[];\n    uploads?: IFileUpload[];\n    leadEmail?: string\n    action?: IAction\n}\n\ninterface IAction {\n    id?: string;\n    elements?: Array<{\n        type: string;\n        label: string;\n    }>;\n    mapping?: {\n        approve: string;\n        reject: string;\n        toolCalls: any[];\n    };\n}\n\ninterface IFileUpload {\n    data?: string;\n    type: string;\n    name: string;\n    mime: string;\n}\n\ninterface IMessage {\n    message: string;\n    type: MessageType;\n    role?: MessageType;\n    content?: string;\n}\n\ntype MessageType = 'apiMessage' | 'userMessage';\n\nexport interface StreamResponse {\n    event: string;\n    data: string;\n}\n\ninterface EmploidClientOptions {\n    baseUrl?: string;\n    apiKey?: string;\n}\n\ntype PredictionResponse<T extends PredictionData> = T['streaming'] extends true\n    ? AsyncGenerator<StreamResponse, void, unknown> // Streaming returns an async generator\n    : Record<string, any>;\n\nexport default class EmploidClient {\n    private baseUrl: string;\n    private apiKey: string;\n\n    constructor(options: EmploidClientOptions = {}) {\n        this.baseUrl = options.baseUrl || 'http://localhost:3000';\n        this.apiKey = options.apiKey || '';\n    }\n\n    // Method to create a new prediction and handle streaming response\n    async createPrediction<T extends PredictionData>(\n        data: T\n    ): Promise<PredictionResponse<T>> {\n        const { chatflowId, streaming } = data;\n\n        // Check if chatflow is available to stream\n        const chatFlowStreamingUrl = `${this.baseUrl}/api/v1/chatflows-streaming/${chatflowId}`;\n        const resp = await fetch(chatFlowStreamingUrl, {\n            method: 'GET',\n            headers: {\n                'Content-Type': 'application/json',\n            },\n        });\n\n        const chatFlowStreamingData = await resp.json();\n        const isChatFlowAvailableToStream =\n            chatFlowStreamingData.isStreaming || false;\n\n        const predictionUrl = `${this.baseUrl}/api/v1/prediction/${chatflowId}`;\n\n        const options: any = {\n            method: 'POST',\n            headers: {\n                'Content-Type': 'application/json',\n            },\n            body: JSON.stringify(data),\n        };\n        if (this.apiKey) {\n            options.headers['Authorization'] = `Bearer ${this.apiKey}`;\n        }\n\n        if (isChatFlowAvailableToStream && streaming) {\n            return {\n                async *[Symbol.asyncIterator]() {\n                    const response = await fetch(predictionUrl, options);\n\n                    if (!response.ok) {\n                        throw new Error(\n                            `HTTP error! status: ${response.status}`\n                        );\n                    }\n\n                    //@ts-ignore\n                    const reader = response.body.getReader();\n                    const decoder = new TextDecoder();\n                    let buffer = '';\n\n                    try {\n                        while (true) {\n                            const { done, value } = await reader.read();\n                            if (done) break;\n\n                            buffer += decoder.decode(value, { stream: true });\n                            const lines = buffer.split('\\n');\n                            buffer = lines.pop() || '';\n\n                            for (const line of lines) {\n                                if (line.trim() === '') continue;\n                                if (line.startsWith('data:')) {\n                                    const stringifiedJson = line.replace(\n                                        'data:',\n                                        ''\n                                    );\n                                    const event = JSON.parse(stringifiedJson);\n                                    yield event;\n                                }\n                            }\n                        }\n                    } finally {\n                        reader.releaseLock();\n                    }\n                },\n            } as unknown as Promise<PredictionResponse<T>>;\n        } else {\n            try {\n                const response = await fetch(predictionUrl, options);\n                const resp = await response.json();\n                return resp as Promise<PredictionResponse<T>>;\n            } catch (error) {\n                throw new Error('Error creating prediction');\n            }\n        }\n    }\n}"]}

package/dist/client.d.ts

@@ -0,0 +1,149 @@
+import { Models } from './models';
+type Payload = {
+    [key: string]: any;
+};
+type UploadProgress = {
+    $id: string;
+    progress: number;
+    sizeUploaded: number;
+    chunksTotal: number;
+    chunksUploaded: number;
+};
+type Headers = {
+    [key: string]: string;
+};
+declare class AppcondaException extends Error {
+    code: number;
+    response: string;
+    type: string;
+    constructor(message: string, code?: number, type?: string, response?: string);
+}
+declare class Client {
+    static CHUNK_SIZE: number;
+    config: {
+        endpoint: string;
+        selfSigned: boolean;
+        project: string;
+        mode: string;
+        key: string;
+        jwt: string;
+        locale: string;
+        session: string;
+        forwardeduseragent: string;
+    };
+    headers: Headers;
+    private fetchImpl?;
+    /**
+     * Set Endpoint
+     *
+     * Your project endpoint
+     *
+     * @param {string} endpoint
+     *
+     * @returns {this}
+     */
+    setEndpoint(endpoint: string): this;
+    /**
+     * Set self-signed
+     *
+     * @param {boolean} selfSigned
+     *
+     * @returns {this}
+     */
+    setSelfSigned(selfSigned: boolean): this;
+    /**
+     * Add header
+     *
+     * @param {string} header
+     * @param {string} value
+     *
+     * @returns {this}
+     */
+    addHeader(header: string, value: string): this;
+    /**
+     * Set custom fetch implementation.
+     *
+     * Useful for Node.js versions without a global fetch.
+     */
+    setFetch(fetchImpl: typeof fetch): this;
+    private getFetch;
+    /**
+     * Set Project
+     *
+     * Your project ID
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setProject(value: string): this;
+    /**
+   * Set Mode
+   *
+   * @param value string
+   *
+   * @return {this}
+   */
+    setMode(value: string): this;
+    /**
+     * Set Key
+     *
+     * Your secret API key
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setKey(value: string): this;
+    /**
+     * Set JWT
+     *
+     * Your secret JSON Web Token
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setJWT(value: string): this;
+    /**
+     * Set Locale
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setLocale(value: string): this;
+    /**
+     * Set Session
+     *
+     * The user session to authenticate with
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setSession(value: string): this;
+    /**
+     * Set ForwardedUserAgent
+     *
+     * The user agent string of the client that made the request
+     *
+     * @param value string
+     *
+     * @return {this}
+     */
+    setForwardedUserAgent(value: string): this;
+    setFallbackCookies(value: string): this;
+    prepareRequest(method: string, url: URL, headers?: Headers, params?: Payload): {
+        uri: string;
+        options: RequestInit;
+    };
+    chunkedUpload(method: string, url: URL, headers: Headers | undefined, originalPayload: Payload | undefined, onProgress: (progress: UploadProgress) => void): Promise<any>;
+    redirect(method: string, url: URL, headers?: Headers, params?: Payload): Promise<string>;
+    call(method: string, url: URL, headers?: Headers, params?: Payload, responseType?: string): Promise<any>;
+    static flatten(data: Payload, prefix?: string): Payload;
+}
+export { Client, AppcondaException };
+export { Query } from './query';
+export type { Models, Payload, UploadProgress };
+export type { QueryTypes, QueryTypesList } from './query';