@appconda/sdk 1.0.437 → 1.0.438

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":"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","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/index.d.ts

@@ -1,2 +1,3 @@
 export * from './modules';
 export { getSDKForService } from './getSDKForService';
+export * from './EmploidClient';

package/dist/index.js

@@ -1,3 +1,4 @@
 export * from './modules';
 export { getSDKForService } from './getSDKForService';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vZHVsZXMnO1xuZXhwb3J0IHsgZ2V0U0RLRm9yU2VydmljZSB9IGZyb20gJy4vZ2V0U0RLRm9yU2VydmljZSc7XG5cblxuIl19
+export * from './EmploidClient';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDdEQsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9kdWxlcyc7XG5leHBvcnQgeyBnZXRTREtGb3JTZXJ2aWNlIH0gZnJvbSAnLi9nZXRTREtGb3JTZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vRW1wbG9pZENsaWVudCc7XG5cbiJdfQ==

package/package.json

@@ -2,7 +2,7 @@
   "name": "@appconda/sdk",
   "homepage": "https://appconda.io/support",
   "description": "Appconda is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API",
-  "version": "1.0.437",
+  "version": "1.0.438",
   "license": "BSD-3-Clause",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/EmploidClient.ts

@@ -0,0 +1,149 @@
+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> // Streaming returns an async generator
+    : Record<string, any>;
+
+export default class EmploidClient {
+    private baseUrl: string;
+    private apiKey: string;
+
+    constructor(options: EmploidClientOptions = {}) {
+        this.baseUrl = options.baseUrl || 'http://localhost:3000';
+        this.apiKey = options.apiKey || '';
+    }
+
+    // Method to create a new prediction and handle streaming response
+    async createPrediction<T extends PredictionData>(
+        data: T
+    ): Promise<PredictionResponse<T>> {
+        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: any = {
+            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();
+                    }
+                },
+            } as unknown as Promise<PredictionResponse<T>>;
+        } else {
+            try {
+                const response = await fetch(predictionUrl, options);
+                const resp = await response.json();
+                return resp as Promise<PredictionResponse<T>>;
+            } catch (error) {
+                throw new Error('Error creating prediction');
+            }
+        }
+    }
+}

package/src/index.ts

@@ -1,4 +1,4 @@
 export * from './modules';
 export { getSDKForService } from './getSDKForService';
-
+export * from './EmploidClient';