psadk 1.1.0

package/build/module/lib/PSAI.js

@@ -0,0 +1,314 @@
+// import { EmbeddingsInterface } from '@langchain/core/embeddings';
+// fetch-retry can also wrap Node.js's native fetch API implementation:
+const fetch = require('fetch-retry')(global.fetch);
+import { JwtUtils } from './jwt';
+import { PSAgentLogger } from './PSAgentLogger';
+import express from 'express';
+const log = new PSAgentLogger();
+let existingToken = {
+    service_token: null,
+    refresh_token: null,
+    expires: new Date(0),
+    service_expires: new Date(0)
+};
+// export default class AIHelper implements EmbeddingsInterface{
+export class PSAI {
+    token;
+    dimensions;
+    baseUrl;
+    log;
+    clientid;
+    constructor(token, baseUrl, log) {
+        this.token = token;
+        this.baseUrl = baseUrl || process.env.PS_API_URL || '';
+        this.clientid = process.env.PS_CLIENT_ID || '';
+        this.dimensions = 1536; // default to 1536 dimensions (for text-embedding-3-small)
+        this.log = log || new PSAgentLogger();
+    }
+    getDimensions(embeddingModel = 'text-embedding-3-small') {
+        if (embeddingModel === 'text-embedding-3-small') {
+            return 1536;
+        }
+        else if (embeddingModel === 'text-embedding-3-large') {
+            return 3072;
+        }
+        else if (embeddingModel === 'text-embedding-ada-002') {
+            return 1536;
+        }
+        else {
+            return this.dimensions;
+        }
+    }
+    async embedQuery(text, embeddingModel = 'text-embedding-3-small') {
+        const response = await fetch(`${this.baseUrl}/api/v1/vectors/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.token}`,
+                'x-client-id': this.clientid || '',
+            },
+            body: JSON.stringify({
+                input: text,
+                model: embeddingModel,
+                "dimensions": this.getDimensions(embeddingModel),
+            }),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            this.log.error(`Failed to fetch embedding: ${response.status} ${response.statusText}`, data);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return data.data[0].embedding;
+    }
+    async embedDocuments(text, embeddingModel = 'text-embedding-3-small') {
+        const response = await fetch(`${this.baseUrl}/api/v1/vectors/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.token}`,
+                'x-client-id': this.clientid || '',
+            },
+            body: JSON.stringify({
+                input: text,
+                model: embeddingModel,
+                "dimensions": this.getDimensions(embeddingModel),
+            }),
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            this.log.error(`Failed to fetch embedding: ${response.status} ${response.statusText}`, data);
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return data.data.map((item) => item.embedding);
+    }
+    async getModels() {
+        const lres = await fetch(`${this.baseUrl}/api/v1/llm/models`, {
+            headers: {
+                'Authorization': `Bearer ${this.token}`,
+            }
+        });
+        if (!lres.ok) {
+            this.log.error(`Failed to fetch LLM models: ${lres.status} ${lres.statusText}`);
+        }
+        const { data: models } = await lres.json();
+        return models;
+    }
+    async llm(prompt, model = "o3-mini", systemmsg = "You are a helpful assistant. Answer as concisely as possible.") {
+        try {
+            const res = await fetch(`${this.baseUrl}/api/v1/llm/chat/completions`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${this.token}`,
+                },
+                body: JSON.stringify({
+                    model,
+                    messages: [
+                        { role: "system", content: systemmsg },
+                        { role: "user", content: prompt }
+                    ]
+                }),
+                retries: 3,
+                retryOn: function (attempt, error, response) {
+                    // retry on any network error, or 4xx or 5xx status codes
+                    if (error !== null || response.status >= 400 && attempt < 4) {
+                        this.log.warn(`retrying execute agent, attempt number ${attempt + 1}`);
+                        return true;
+                    }
+                    return false;
+                },
+                retryDelay: function (attempt, _error, _response) {
+                    return Math.pow(2, attempt) * 1000; // 1000, 2000, 4000
+                }
+            });
+            if (!res.ok) {
+                this.log.debug(`Failed to fetch LLM completion: ${res.status} ${res.statusText}`);
+                try {
+                    const errorData = (await res.json());
+                    this.log.debug(errorData);
+                    throw new Error(`LLM call failed.\n\n status: ${res.status}, details: ${errorData}`);
+                }
+                catch (e) {
+                    throw new Error(`LLM call failed.\n\n status: ${res.status}, and could not parse error response`);
+                }
+            }
+            const data = await res.json();
+            return data;
+        }
+        catch (error) {
+            this.log.debug('Error in llm call:', error);
+            throw error;
+        }
+    }
+    static async getServiceToken(options) {
+        const { baseurl = process.env.PS_API_URL || '', appkey = process.env.PS_SVC_APP_KEY || '', clientid = process.env.PS_SVC_CLIENT_ID || '', clientsecret = process.env.PS_SVC_CLIENT_SECRET || '' } = options || {};
+        if (!baseurl || !appkey || !clientid || !clientsecret) {
+            throw new Error('Missing required environment variables for service token retrieval');
+        }
+        const currentTime = new Date();
+        // Check if the existing token is still valid and expires after 20 minutes
+        if (existingToken && existingToken.service_token && existingToken.service_expires.getTime() > (currentTime.getTime() + 20 * 60000)) {
+            return existingToken.service_token;
+        }
+        const token = Buffer.from(`${clientid}:${clientsecret}`).toString('base64');
+        if (existingToken && existingToken.expires > currentTime) {
+            log.debug(`Found existing refresh token: ${existingToken.refresh_token}`);
+            const tres = await fetch(`${baseurl}/api/v2/auth/refreshtoken?client=machine`, {
+                headers: {
+                    'Authorization': `Basic ${token}`,
+                    'app-key': appkey || '',
+                    'rt': existingToken.refresh_token || ''
+                }
+            });
+            if (tres.ok) {
+                const { accessToken, refreshToken } = (await tres.json());
+                const spayload = JwtUtils.decode(accessToken);
+                const rpayload = JwtUtils.decode(refreshToken);
+                existingToken.service_token = accessToken;
+                existingToken.refresh_token = refreshToken;
+                existingToken.expires = new Date(rpayload?.exp * 1000);
+                existingToken.service_expires = new Date(spayload?.exp * 1000);
+                log.debug(`Refreshed service token: expires at ${existingToken.service_expires}`);
+                return accessToken;
+            }
+            else {
+                log.debug(`Failed to refresh service token, status: ${tres.status}`);
+            }
+        }
+        const tres = await fetch(`${baseurl}/api/v2/auth/login?client=machine&source=custom`, {
+            headers: {
+                'Authorization': `Basic ${token}`,
+                'app-key': appkey || ''
+            }
+        });
+        const { serviceToken, refreshToken } = (await tres.json());
+        const spayload = JwtUtils.decode(serviceToken);
+        const rpayload = JwtUtils.decode(refreshToken);
+        log.debug(`service token expires: ${JSON.stringify(new Date(spayload?.exp * 1000))}`);
+        log.debug(`refresh token expires: ${JSON.stringify(new Date(rpayload?.exp * 1000))}`);
+        existingToken.service_token = serviceToken;
+        existingToken.refresh_token = refreshToken;
+        existingToken.expires = new Date(rpayload?.exp * 1000);
+        existingToken.service_expires = new Date(spayload?.exp * 1000);
+        return serviceToken;
+    }
+    /**
+     * fetch access token by launching a local server to listen for the callback
+     * @param options - baseUrl and appKey for authentication
+     * @returns accessToken and refreshToken
+     * @throws error if any required values are missing or if authentication fails
+     */
+    static async getAuthToken(options) {
+        const { baseurl = options?.baseUrl || process.env.PS_API_URL || '', appkey = options?.appKey || process.env.PS_APP_KEY || '', } = options || {};
+        if (baseurl === '' || appkey === '') {
+            throw new Error('Missing required values baseUrl & appKey or default environment variables PS_API_URL/PS_APP_KEY for access token retrieval');
+        }
+        try {
+            let isCallbackFinished = false;
+            let callBackError = null;
+            let accessToken = null;
+            let refreshToken = null;
+            let appInitialized = false;
+            const app = express();
+            const router = express.Router();
+            router.use(express.json()); // for parsing application/json
+            router.use(express.urlencoded({ extended: true })); // for parsing application/x-www-form-urlencoded
+            router.get('/callback', (req, res) => {
+                const status = req.query.status;
+                if (status !== "success") {
+                    log.error(`Authentication failed with status: ${status}`);
+                    callBackError = `Authentication failed with status: ${status}`;
+                    isCallbackFinished = true;
+                    return res.status(400).send('Authentication failed');
+                }
+                log.debug("Authentication successful.");
+                accessToken = req.query["at"];
+                refreshToken = req.query["rt"];
+                if (!accessToken || !refreshToken) {
+                    log.error('Missing access token or refresh token in callback');
+                    callBackError = 'Missing access token or refresh token in callback';
+                    isCallbackFinished = true;
+                    return res.status(400).send('Missing tokens');
+                }
+                callBackError = null;
+                isCallbackFinished = true;
+                return res.status(200).send('Authentication successful! You can close this window.');
+            });
+            router.get('/login', async (_req, res) => {
+                const rurl = encodeURIComponent('http://localhost:3133/callback');
+                const loginUrl = `${baseurl}/api/v2/auth/login?client=desktop&redirect_url=${rurl}`;
+                const lres = await fetch(loginUrl, {
+                    headers: { 'app-key': appkey || '' }
+                });
+                if (lres.status >= 400) {
+                    log.error(`Failed to initiate login: ${lres.status} ${lres.statusText}`);
+                    callBackError = `Failed to initiate login: ${lres.status} ${lres.statusText}`;
+                    isCallbackFinished = true;
+                    return res.status(500).send('Failed to initiate login');
+                }
+                const data = lres.body;
+                if (!data) {
+                    log.error('No response body from login initiation');
+                    callBackError = 'No response body from login initiation';
+                    isCallbackFinished = true;
+                    return res.status(500).send('No response body from login initiation');
+                }
+                const reader = data.getReader();
+                const decoder = new TextDecoder('utf-8');
+                let lresText = '';
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    lresText += decoder.decode(value);
+                }
+                if (!lresText || lresText.length === 0) {
+                    log.error('Empty response body from login initiation');
+                    callBackError = 'Empty response body from login initiation';
+                    isCallbackFinished = true;
+                    return res.status(500).send('Empty response body from login initiation');
+                }
+                log.debug('Redirecting to authentication provider');
+                return res.redirect(lresText);
+            });
+            app.use('', router);
+            app.listen(3133, () => {
+                log.debug('Listening on port 3133 for OAuth callback');
+                appInitialized = true;
+            }).on('error', (err) => {
+                log.error('Failed to start local server:', err);
+                callBackError = `Failed to start local server: ${err.message}`;
+                isCallbackFinished = true;
+                appInitialized = true;
+            });
+            do {
+                await new Promise(resolve => setTimeout(resolve, 500));
+            } while (!appInitialized && !callBackError);
+            if (appInitialized) {
+                console.log(`Please open the following URL in your browser to authenticate:\n\nhttp://localhost:3133/login\n`);
+                // Open the URL in the default browser
+                const open = (await import('open')).default;
+                await open(`http://localhost:3133/login`);
+                do {
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                } while (!isCallbackFinished && !callBackError);
+            }
+            if (callBackError) {
+                throw new Error(callBackError);
+            }
+            if (!accessToken || !refreshToken) {
+                throw new Error('Failed to obtain tokens from callback');
+            }
+            log.debug(`Obtained access token and refresh token from callback`);
+            return {
+                accessToken: accessToken,
+                refreshToken: refreshToken
+            };
+        }
+        catch (error) {
+            log.error('Error in getAccessToken:', error);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PSAI.js","sourceRoot":"","sources":["../../../src/lib/PSAI.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,uEAAuE;AACvE,MAAM,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAgB,MAAM,OAAO,CAAC;AAC/C,OAAO,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC9C,OAAO,OAA8B,MAAM,SAAS,CAAC;AAErD,MAAM,GAAG,GAAG,IAAI,aAAa,EAAE,CAAC;AAEhC,IAAI,aAAa,GAKb;IACF,aAAa,EAAE,IAAI;IACnB,aAAa,EAAE,IAAI;IACnB,OAAO,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC;IACpB,eAAe,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC;CAC7B,CAAC;AAEF,gEAAgE;AAChE,MAAM,OAAO,IAAI;IACE,KAAK,CAAS;IACvB,UAAU,CAAQ;IACT,OAAO,CAAS;IAChB,GAAG,CAAgB;IACnB,QAAQ,CAAS;IAElC,YAAY,KAAa,EAAE,OAAgB,EAAE,GAAmB;QAC9D,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC;QACvD,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC;QAC/C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC,0DAA0D;QAClF,IAAI,CAAC,GAAG,GAAG,GAAG,IAAI,IAAI,aAAa,EAAE,CAAC;IACxC,CAAC;IAEM,aAAa,CAAC,cAAc,GAAC,wBAAwB;QAC1D,IAAI,cAAc,KAAK,wBAAwB,EAAE,CAAC;YAC9C,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,cAAc,KAAK,wBAAwB,EAAE,CAAC;YACvD,OAAO,IAAI,CAAC;QACd,CAAC;aAAM,IAAI,cAAc,KAAK,wBAAwB,EAAE,CAAC;YACvD,OAAO,IAAI,CAAC;QACd,CAAC;aAAK,CAAC;YACL,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;IACL,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,IAAY,EAAE,cAAc,GAAC,wBAAwB;QACpE,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,4BAA4B,EAAE;YACxE,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,eAAe,EAAE,UAAU,IAAI,CAAC,KAAK,EAAE;gBACvC,aAAa,EAAE,IAAI,CAAC,QAAQ,IAAE,EAAE;aACjC;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gBACnB,KAAK,EAAE,IAAI;gBACX,KAAK,EAAE,cAAc;gBACrB,YAAY,EAAE,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;aACjD,CAAC;SACH,CAAC,CAAC;QACH,MAAM,IAAI,GAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,8BAA8B,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,CAAC;YAC7F,MAAM,IAAI,KAAK,CAAC,uBAAuB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAqB,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,IAAc,EAAE,cAAc,GAAC,wBAAwB;QAC1E,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,4BAA4B,EAAE;YACxE,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,eAAe,EAAE,UAAU,IAAI,CAAC,KAAK,EAAE;gBACvC,aAAa,EAAE,IAAI,CAAC,QAAQ,IAAE,EAAE;aACjC;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gBACnB,KAAK,EAAE,IAAI;gBACX,KAAK,EAAE,cAAc;gBACrB,YAAY,EAAE,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;aACjD,CAAC;SACH,CAAC,CAAC;QACH,MAAM,IAAI,GAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,8BAA8B,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,CAAC;YAC7F,MAAM,IAAI,KAAK,CAAC,uBAAuB,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAe,CAAC;IACpE,CAAC;IAGD,KAAK,CAAC,SAAS;QACb,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,oBAAoB,EAAE;YAC1D,OAAO,EAAE;gBACP,eAAe,EAAE,UAAU,IAAI,CAAC,KAAK,EAAE;aACxC;SACF,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;YACb,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,+BAA+B,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAClF,CAAC;QACD,MAAM,EAAC,IAAI,EAAC,MAAM,EAAC,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC;QACxC,OAAO,MAAM,CAAC;IAClB,CAAC;IAED,KAAK,CAAC,GAAG,CAAC,MAAa,EAAE,KAAK,GAAG,SAAS,EAAE,SAAS,GAAC,+DAA+D;QACnH,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,8BAA8B,EAAE;gBACrE,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE;oBACP,cAAc,EAAE,kBAAkB;oBAClC,eAAe,EAAE,UAAU,IAAI,CAAC,KAAK,EAAE;iBACxC;gBACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,KAAK;oBACL,QAAQ,EAAE;wBACR,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE;wBACtC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE;qBAClC;iBACF,CAAC;gBACF,OAAO,EAAE,CAAC;gBACV,OAAO,EAAE,UAAS,OAAW,EAAE,KAAS,EAAE,QAAY;oBACpD,yDAAyD;oBACzD,IAAI,KAAK,KAAK,IAAI,IAAI,QAAQ,CAAC,MAAM,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;wBAC5D,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,0CAA0C,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC;wBACvE,OAAO,IAAI,CAAC;oBACd,CAAC;oBACD,OAAO,KAAK,CAAC;gBACf,CAAC;gBACD,UAAU,EAAE,UAAS,OAAW,EAAE,MAAU,EAAE,SAAa;oBACzD,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC,CAAC,mBAAmB;gBACzD,CAAC;aACF,CAAC,CAAC;YACH,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;gBACZ,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,mCAAmC,GAAG,CAAC,MAAM,IAAI,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC;gBAClF,IAAI,CAAC;oBACH,MAAM,SAAS,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;oBACrC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;oBACzB,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,CAAC,MAAM,cAAc,SAAS,EAAE,CAAC,CAAC;gBACvF,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBACX,MAAM,IAAI,KAAK,CAAC,gCAAgC,GAAG,CAAC,MAAM,sCAAsC,CAAC,CAAC;gBACpG,CAAC;YACH,CAAC;YACD,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAC;YAC9B,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,oBAAoB,EAAE,KAAK,CAAC,CAAC;YAC5C,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEM,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,OAA+B;QACjE,MAAM,EACJ,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,EACtC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,EACzC,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE,EAC7C,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,oBAAoB,IAAI,EAAE,EACtD,GAAG,OAAO,IAAI,EAAE,CAAC;QAElB,IAAI,CAAC,OAAO,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,IAAI,CAAC,YAAY,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;QACxF,CAAC;QACD,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;QAC/B,0EAA0E;QAC1E,IAAI,aAAa,IAAI,aAAa,CAAC,aAAa,IAAI,aAAa,CAAC,eAAe,CAAC,OAAO,EAAE,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,EAAE,CAAC;YACnI,OAAO,aAAa,CAAC,aAAa,CAAC;QACrC,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,QAAQ,IAAI,YAAY,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC5E,IAAI,aAAa,IAAI,aAAa,CAAC,OAAO,GAAG,WAAW,EAAE,CAAC;YACzD,GAAG,CAAC,KAAK,CAAC,iCAAiC,aAAa,CAAC,aAAa,EAAE,CAAC,CAAC;YAC1E,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,GAAG,OAAO,0CAA0C,EAAE;gBAC7E,OAAO,EAAE;oBACP,eAAe,EAAE,SAAS,KAAK,EAAE;oBACjC,SAAS,EAAE,MAAM,IAAI,EAAE;oBACvB,IAAI,EAAE,aAAa,CAAC,aAAa,IAAI,EAAE;iBACxC;aACF,CAAC,CAAC;YACH,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;gBACZ,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAmD,CAAC;gBAC5G,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,WAAW,CAAiB,CAAC;gBAC9D,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAiB,CAAC;gBAC/D,aAAa,CAAC,aAAa,GAAG,WAAW,CAAC;gBAC1C,aAAa,CAAC,aAAa,GAAG,YAAY,CAAC;gBAC3C,aAAa,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;gBACvD,aAAa,CAAC,eAAe,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;gBAC/D,GAAG,CAAC,KAAK,CAAC,uCAAuC,aAAa,CAAC,eAAe,EAAE,CAAC,CAAC;gBAClF,OAAO,WAAW,CAAC;YACrB,CAAC;iBAAM,CAAC;gBACN,GAAG,CAAC,KAAK,CAAC,4CAA4C,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,GAAG,OAAO,iDAAiD,EAAE;YACpF,OAAO,EAAE;gBACP,eAAe,EAAE,SAAS,KAAK,EAAE;gBACjC,SAAS,EAAE,MAAM,IAAI,EAAE;aACxB;SACF,CAAC,CAAC;QACH,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAoD,CAAC;QAC9G,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAiB,CAAC;QAC/D,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,YAAY,CAAiB,CAAC;QAE/D,GAAG,CAAC,KAAK,CAAC,0BAA0B,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACtF,GAAG,CAAC,KAAK,CAAC,0BAA0B,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;QACtF,aAAa,CAAC,aAAa,GAAG,YAAY,CAAC;QAC3C,aAAa,CAAC,aAAa,GAAG,YAAY,CAAC;QAC3C,aAAa,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;QACvD,aAAa,CAAC,eAAe,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;QAE/D,OAAO,YAAY,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,OAA+B;QAC9D,MAAM,EACJ,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,EAC1D,MAAM,GAAG,OAAO,EAAE,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,EAAE,GACzD,GAAG,OAAO,IAAI,EAAE,CAAC;QAClB,IAAI,OAAO,KAAG,EAAE,IAAI,MAAM,KAAG,EAAE,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,4HAA4H,CAAC,CAAC;QAChJ,CAAC;QAED,IAAI,CAAC;YACH,IAAI,kBAAkB,GAAG,KAAK,CAAC;YAC/B,IAAI,aAAa,GAAO,IAAI,CAAC;YAC7B,IAAI,WAAW,GAAkB,IAAI,CAAC;YACtC,IAAI,YAAY,GAAkB,IAAI,CAAC;YACvC,IAAI,cAAc,GAAG,KAAK,CAAC;YAC3B,MAAM,GAAG,GAAG,OAAO,EAAE,CAAC;YACtB,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YAChC,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAA,CAAC,+BAA+B;YAC1D,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAA,CAAC,gDAAgD;YAGnG,MAAM,CAAC,GAAG,CAAC,WAAW,EAAE,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;gBACtD,MAAM,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC;gBAChC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBACzB,GAAG,CAAC,KAAK,CAAC,sCAAsC,MAAM,EAAE,CAAC,CAAC;oBAC1D,aAAa,GAAG,sCAAsC,MAAM,EAAE,CAAC;oBAC/D,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;gBACvD,CAAC;gBACD,GAAG,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;gBACxC,WAAW,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAW,CAAC;gBACxC,YAAY,GAAG,GAAG,CAAC,KAAK,CAAC,IAAI,CAAW,CAAC;gBACzC,IAAI,CAAC,WAAW,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClC,GAAG,CAAC,KAAK,CAAC,mDAAmD,CAAC,CAAC;oBAC/D,aAAa,GAAG,mDAAmD,CAAC;oBACpE,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;gBAChD,CAAC;gBACD,aAAa,GAAG,IAAI,CAAC;gBACrB,kBAAkB,GAAG,IAAI,CAAC;gBAC1B,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;YACvF,CAAC,CAAC,CAAC;YACH,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAa,EAAE,GAAa,EAAE,EAAE;gBAC1D,MAAM,IAAI,GAAG,kBAAkB,CAAC,gCAAgC,CAAC,CAAC;gBAClE,MAAM,QAAQ,GAAG,GAAG,OAAO,kDAAkD,IAAI,EAAE,CAAC;gBACpF,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,QAAQ,EAAE;oBACjC,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,IAAI,EAAE,EAAE;iBACrC,CAAC,CAAC;gBACH,IAAI,IAAI,CAAC,MAAM,IAAE,GAAG,EAAE,CAAC;oBACrB,GAAG,CAAC,KAAK,CAAC,6BAA6B,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;oBACzE,aAAa,GAAG,6BAA6B,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;oBAC9E,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,0BAA0B,CAAC,CAAC;gBAC1D,CAAC;gBACD,MAAM,IAAI,GAAkB,IAAI,CAAC,IAAiC,CAAC;gBACnE,IAAI,CAAC,IAAI,EAAE,CAAC;oBACV,GAAG,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;oBACpD,aAAa,GAAG,wCAAwC,CAAC;oBACzD,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;gBACxE,CAAC;gBACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;gBAChC,MAAM,OAAO,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;gBACzC,IAAI,QAAQ,GAAG,EAAE,CAAC;gBAClB,OAAO,IAAI,EAAE,CAAC;oBACZ,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;oBAC5C,IAAI,IAAI;wBAAE,MAAM;oBAChB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBACpC,CAAC;gBACD,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,KAAG,CAAC,EAAE,CAAC;oBACrC,GAAG,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC;oBACvD,aAAa,GAAG,2CAA2C,CAAC;oBAC5D,kBAAkB,GAAG,IAAI,CAAC;oBAC1B,OAAO,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,2CAA2C,CAAC,CAAC;gBAC3E,CAAC;gBACD,GAAG,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;gBACpD,OAAO,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YAChC,CAAC,CAAC,CAAC;YACH,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;YACpB,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE;gBACpB,GAAG,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC;gBACvD,cAAc,GAAG,IAAI,CAAC;YACxB,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAQ,EAAE,EAAE;gBAC1B,GAAG,CAAC,KAAK,CAAC,+BAA+B,EAAE,GAAG,CAAC,CAAC;gBAChD,aAAa,GAAG,iCAAiC,GAAG,CAAC,OAAO,EAAE,CAAC;gBAC/D,kBAAkB,GAAG,IAAI,CAAC;gBAC1B,cAAc,GAAG,IAAI,CAAC;YACxB,CAAC,CAAC,CAAC;YACH,GAAG,CAAC;gBACF,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;YACzD,CAAC,QAAQ,CAAC,cAAc,IAAI,CAAC,aAAa,EAAE;YAC5C,IAAI,cAAc,EAAE,CAAC;gBACnB,OAAO,CAAC,GAAG,CAAC,iGAAiG,CAAC,CAAC;gBAC/G,sCAAsC;gBACtC,MAAM,IAAI,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC;gBAC5C,MAAM,IAAI,CAAC,6BAA6B,CAAC,CAAC;gBAC1C,GAAG,CAAC;oBACF,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;gBACzD,CAAC,QAAQ,CAAC,kBAAkB,IAAI,CAAC,aAAa,EAAE;YAClD,CAAC;YACD,IAAI,aAAa,EAAE,CAAC;gBAClB,MAAM,IAAI,KAAK,CAAC,aAAa,CAAC,CAAC;YACjC,CAAC;YACD,IAAI,CAAC,WAAW,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClC,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;YAC3D,CAAC;YACD,GAAG,CAAC,KAAK,CAAC,uDAAuD,CAAC,CAAC;YACnE,OAAO;gBACL,WAAW,EAAE,WAAW;gBACxB,YAAY,EAAE,YAAY;aAC3B,CAAA;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,GAAG,CAAC,KAAK,CAAC,0BAA0B,EAAE,KAAK,CAAC,CAAC;YAC7C,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CAEF"}

package/build/module/lib/PSAgent.d.ts

@@ -0,0 +1,215 @@
+import { PSAgentConfig } from "./PSAgentConfig";
+import { IPSAgentToolResult, PSAgentTool } from "./PSAgentTool";
+import { PSAgentLogger } from "./PSAgentLogger";
+import { z } from "zod/v4";
+import { PSAgentTask } from "./PSAgentTask";
+import type { AgentCard } from "@a2a-js/sdk";
+import { AgentExecutor, RequestContext, ExecutionEventBus, TaskStore } from "@a2a-js/sdk/server";
+import express from "express";
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * PSAgent class to manage AI agents with tools and tasks
+ * Implements AgentExecutor interface from A2A SDK
+ * Supports starting, resuming, cancelling agents and executing tools
+ * Manages agent state, tools, tasks and interactions with A2A platform
+ * Includes methods for A2A server setup and event fetching
+ *
+ * uses the token from config if not PS_API_TOKEN env variable
+ * adds x-client-id, x-project-id, x-workspace-id from env variables
+ * PS_CLIENT_ID, PS_PROJECT_ID, PS_WORKSPACE_ID respectively for authentication headers
+ *
+ * @example
+ * ```typescript
+ * import { PSAI, PSAgent, PSAgentLogger } from 'psadk';
+ * import dotenv from 'dotenv';
+ * dotenv.config();
+ * async function main() {
+ *   const token = await PSAI.getServiceToken({});
+ *   const HelloAgent = new PSAgent({
+ *     name: 'HelloAgent',
+ *     description: 'A simple hello world agent',
+ *     system_prompt: 'You are a helpful assistant that greets users.',
+ *     model: 'gpt-5',
+ *     tools: [],
+ *     log: new PSAgentLogger({ level: 'info' }),
+ *     token: token,
+ *     port: 41241,
+ *   });
+ *   const { app, port } = HelloAgent.getServer();
+ *   app.listen(port, () => {
+ *     console.log('HelloAgent is running on http://localhost:${port}');
+ *   });
+ * }
+ * main();
+ * ```
+ * @see PSAgentConfig, PSAgentTool, PSAgentTask
+ *
+ * @see
+ * https://dev.lionis.ai/docs/api/v1/agents/create-agent
+ * https://pscode.lioncloud.net/ai-tso/psadk_samples
+ * https://a2aproject.com/docs/getting-started/quickstart
+ *
+ */
+export declare class PSAgent implements AgentExecutor {
+    config: PSAgentConfig;
+    private tools;
+    private tasks;
+    private agentId?;
+    private correlationId?;
+    private readonly log?;
+    private cancelledTasks;
+    cancelTask: (taskId: string, _eventBus: ExecutionEventBus) => Promise<void>;
+    /**
+     * create a new PSAgent with the given config
+     * @param config PSAgentConfig with optional logger
+     */
+    constructor(config: PSAgentConfig & {
+        log?: PSAgentLogger;
+    });
+    /**
+     * Get the Agent Class
+     * @returns Agent class from config or default "LlmAgent"
+     */
+    get AgentClass(): string;
+    /**
+     * Get the Name of the Agent
+     *
+     * @returns Name of the agent from config
+     */
+    get Name(): string;
+    /**
+     * Get the Description of the Agent
+     * @returns Description of the agent from config
+     */
+    get Description(): string;
+    /**
+     * Get the Instruction(System Prompt) of the Agent
+     * @returns Instruction(System prompt) of the agent from config
+     */
+    get Instruction(): string;
+    /**
+     * Get the Model of the Agent
+     * @returns Model of the agent from config
+     */
+    get Model(): string | undefined;
+    /**
+     * Get the Input Schema of the Agent
+     * @returns Input schema of the agent from config
+     */
+    get InputSchema(): z.core.JSONSchema.BaseSchema | undefined;
+    /**
+     * Get the Output Schema of the Agent
+     * @returns Output schema of the agent from config
+     */
+    get OutputSchema(): z.core.JSONSchema.BaseSchema | undefined;
+    /**
+     * Get the Token for the Agent
+     * @returns Token of the agent from config
+     */
+    get Token(): string | undefined;
+    /**
+     * Set the Token for the Agent
+     * @param value Token string to set in config
+     */
+    set Token(value: string | undefined);
+    /**
+     * Get the Tools for the Agent
+     * Includes both config tools and dynamically added tools
+     * @returns Array of PSAgentTool instances
+     */
+    get Tools(): PSAgentTool[];
+    /**
+     * Get the Tasks for the Agent
+     * Includes both config tasks and dynamically added tasks
+     * @returns Array of PSAgentTask instances
+     */
+    get Tasks(): PSAgentTask[];
+    /**
+     * Get the Agent ID after starting the agent
+     * @returns Agent ID string or undefined if not started
+     */
+    get AgentId(): string | undefined;
+    /**
+     * Get the Correlation ID after starting the agent
+     * @returns Correlation ID string or undefined if not started
+     */
+    get CorrelationId(): string | undefined;
+    /**
+     * Add tools to the agent dynamically
+     * @param tool PSAgentTool to add to the agent
+     */
+    addTool(tool: PSAgentTool): void;
+    private getToken;
+    private getAuthHeaders;
+    private getBaseUrl;
+    /**
+     * start a new temp agent on the agent platform
+     * @param input input to the agent the schema should match InputSchema if provided
+     * @param history history of messages for agent context
+     * @param log logger to use for logging, defaults to agent's logger
+     * @returns Correlation ID of the started agent
+     */
+    start(input: Object, history?: any[], log?: PSAgentLogger): Promise<string>;
+    /**
+     * resume the agent with tool output after a tool execution or human input
+     * @param tooloutput output from the tool execution to send back to the agent
+     * @returns
+     */
+    resume(tooloutput: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * deletes the agent running on the platform
+     * @param log optional logger to use for logging, defaults to agent's logger
+     */
+    cancel(log?: PSAgentLogger): Promise<void>;
+    /**
+     * Gets all the events for the current agent run identified correlation ID
+     * @returns Array of event objects for the current agent's correlation ID
+     * @see https://dev.lionis.ai/api/v1/events/events?correlationId={{correlation_id}}
+     */
+    getEvents(): Promise<Array<Record<string, any>>>;
+    /**
+     * Invoke the tool with the given name and input
+     * @remarks
+     * The input object should match the tool's input schema
+     *
+     * @param toolName name of the tool to execute
+     * @param input input object for the tool execution should match tool's input schema
+     * @param log logger to use for logging, defaults to agent's logger
+     * @returns output from the tool execution or error if any
+     *
+     * @example
+     * Example input for PSArtifactTool:
+     * ```json
+     * {
+     *   "name": "example_artifact",
+     *   "action": "write",
+     *   "content": "This is an example artifact content."
+     * }
+     * ```
+     */
+    executeTool(toolName: string, input: Record<string, any>, log?: PSAgentLogger): Promise<IPSAgentToolResult>;
+    /**
+     *
+     * @param requestContext
+     * @param eventBus
+     * @returns
+     */
+    execute(requestContext: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
+    private getHostIPAddress;
+    /**
+     * Port for A2A express server
+     * @returns Port number from config or default 41241
+     */
+    private getPort;
+    /**
+     *
+     * @param taskStore Optional TaskStore, defaults to InMemoryTaskStore
+     * @returns A2A Express app
+     */
+    getServer(taskStore?: TaskStore): {
+        app: express.Express;
+        port: number;
+    };
+    getAgentCard(): AgentCard;
+    static FromConfigFile(config_path: string): PSAgent;
+}