openkbs 0.0.51 → 0.0.53

package/templates/scripts/utils/agent_client.js

@@ -2,6 +2,7 @@ const https = require('https');
 const fs = require('fs');
 const readline = require('readline');
 const path = require('path');
+const { URL } = require('url');
 
 class OpenKBSAgentClient {
     constructor() {
@@ -12,7 +13,7 @@ class OpenKBSAgentClient {
 
     findSettings() {
         let currentDir = __dirname;
-        
+
         while (currentDir !== path.parse(currentDir).root) {
             const settingsPath = path.join(currentDir, 'app', 'settings.json');
             if (fs.existsSync(settingsPath)) {
@@ -20,13 +21,13 @@ class OpenKBSAgentClient {
             }
             currentDir = path.dirname(currentDir);
         }
-        
+
         throw new Error('Could not find app/settings.json in parent directories');
     }
 
     findSecretsPath() {
         let currentDir = __dirname;
-        
+
         while (currentDir !== path.parse(currentDir).root) {
             const settingsPath = path.join(currentDir, 'app', 'settings.json');
             if (fs.existsSync(settingsPath)) {
@@ -35,24 +36,28 @@ class OpenKBSAgentClient {
             }
             currentDir = path.dirname(currentDir);
         }
-        
+
         throw new Error('Could not find agent directory with app/settings.json');
     }
 
     async getApiKey() {
         if (this.apiKey) return this.apiKey;
-        
+
         if (fs.existsSync(this.secretsPath)) {
             const secrets = JSON.parse(fs.readFileSync(this.secretsPath, 'utf8'));
             this.apiKey = secrets.apiKey;
             return this.apiKey;
         }
-        
+
         this.apiKey = await this.promptForApiKey();
         this.saveApiKey(this.apiKey);
         return this.apiKey;
     }
 
+    async init() {
+        await this.getApiKey();
+    }
+
     async promptForApiKey() {
         return new Promise((resolve) => {
             const rl = readline.createInterface({
@@ -89,89 +94,170 @@ class OpenKBSAgentClient {
         fs.writeFileSync(this.secretsPath, JSON.stringify({ apiKey: key }, null, 2));
     }
 
+    /**
+     * Run a job and get response from the agent
+     *
+     * @param {string|Array} message - Either:
+     *   - String: "Do something ..."
+     *   - Array: [
+     *       {type:"text", text:"Process this invoice"},
+     *       {type:"image_url", image_url:{url:"https://files.openkbs.com/invoice.png"}}
+     *     ]
+     *
+     * @returns {Promise<Object>} Response structure:
+     *   {
+     *     data: {
+     *       type: 'TEXT' | 'CUSTOM_TYPE',
+     *       content: '...' | data: {...}
+     *     },
+     *     chatId: 'xxx-xxx',
+     *     msgId: 'msg_xxx'
+     *   }
+     */
     async runJob(message, options = {}) {
         const apiKey = await this.getApiKey();
-        
-        if (!this.settings.kbId) {
-            throw new Error('First use: "openkbs push" to create the agent');
-        }
+        if (!this.settings.kbId) throw new Error('First use: "openkbs push" to create the agent');
 
-        const chatTitle = options.chatTitle || `Task ${new Date().getTime()}`;
-        const chatId = await this.startJob(chatTitle, message, { kbId: this.settings.kbId, apiKey });
-        
-        console.log(`Job ${chatId} created.\nWorking ...`);
-        
-        if (options.poll !== false) {
-            return this.pollForMessages(chatId, { kbId: this.settings.kbId, apiKey });
-        }
-        
-        return chatId;
+        const payload = { message };
+        Object.keys(options).forEach(key => {
+            if (key === 'historyLimit') {
+                payload[key] = Math.min(Math.max(1, options[key]), 100);
+            } else if (options[key] !== undefined) {
+                payload[key] = options[key];
+            }
+        });
+
+        const response = await this.request(
+            `https://${this.settings.kbId}.apps.openkbs.com/api`,
+            payload,
+            { Authorization: `Bearer ${apiKey}` }
+        );
+
+        if (response.chatId) this.lastChatId = response.chatId;
+        return response;
     }
 
-    async startJob(chatTitle, data, app) {
-        const response = await this.makeRequest('https://chat.openkbs.com/', { 
-            ...app, 
-            chatTitle, 
-            message: data 
+    async continueChat(message, chatId = null, options = {}) {
+        const targetChatId = chatId || this.lastChatId;
+        if (!targetChatId) throw new Error('No chatId provided and no previous chat to continue');
+
+        return this.runJob(message, {
+            ...options,
+            chatId: targetChatId,
+            includeHistory: options.includeHistory !== false
         });
-        
-        try {
-            return JSON.parse(response)[0].createdChatId;
-        } catch (error) {
-            if (fs.existsSync(this.secretsPath)) {
-                fs.unlinkSync(this.secretsPath);
-            }
-            throw new Error('Authentication failed.');
-        }
     }
 
-    makeRequest(url, payload) {
+    async uploadFile(filePath, options = {}) {
+        const apiKey = await this.getApiKey();
+        if (!fs.existsSync(filePath)) throw new Error(`File not found: ${filePath}`);
+
+        const fileContent = fs.readFileSync(filePath);
+        const ext = path.extname(filePath);
+        const fileName = options.fileName || `file-${Date.now()}-${Math.random().toString(36).substring(7)}${ext}`;
+        const fileType = options.fileType || this.getMimeType(filePath);
+
+        const presignedResponse = await this.request('https://kb.openkbs.com/', {
+            apiKey,
+            kbId: this.settings.kbId,
+            namespace: 'files',
+            presignedOperation: 'putObject',
+            action: 'createPresignedURL',
+            fileName,
+            fileType
+        }, { Origin: `https://${this.settings.kbId}.apps.openkbs.com` });
+
+        const presignedUrl = presignedResponse.presignedUrl || presignedResponse;
+
+        await this.requestRaw(presignedUrl, fileContent, {
+            'Content-Type': fileType,
+            'Content-Length': fileContent.length
+        }, 'PUT');
+
+        return {
+            fileName,
+            uploaded: true,
+            url: `https://file.openkbs.com/files/${this.settings.kbId}/${fileName}`
+        };
+    }
+
+    getMimeType(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeTypes = {
+            '.pdf': 'application/pdf',
+            '.txt': 'text/plain',
+            '.json': 'application/json',
+            '.jpg': 'image/jpeg',
+            '.jpeg': 'image/jpeg',
+            '.png': 'image/png',
+            '.gif': 'image/gif',
+            '.doc': 'application/msword',
+            '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            '.xls': 'application/vnd.ms-excel',
+            '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            '.csv': 'text/csv',
+            '.html': 'text/html',
+            '.xml': 'application/xml',
+            '.zip': 'application/zip'
+        };
+        return mimeTypes[ext] || 'application/octet-stream';
+    }
+
+    // Unified HTTP request helper
+    async request(url, payload, headers = {}, method = 'POST') {
         return new Promise((resolve, reject) => {
-            const { hostname, pathname } = new URL(url);
+            const { hostname, pathname, search } = new URL(url);
             const req = https.request({
-                hostname, 
-                path: pathname, 
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' }
+                hostname,
+                path: pathname + (search || ''),
+                method,
+                headers: { 'Content-Type': 'application/json', ...headers }
             }, res => {
                 let data = '';
                 res.on('data', chunk => data += chunk);
-                res.on('end', () => resolve(data));
+                res.on('end', () => {
+                    try {
+                        const result = JSON.parse(data);
+                        if (res.statusCode === 401) {
+                            if (fs.existsSync(this.secretsPath)) fs.unlinkSync(this.secretsPath);
+                            reject(new Error('Authentication failed. Please run "node scripts/run_job.js init" to reconfigure.'));
+                        } else if (res.statusCode !== 200) {
+                            reject(new Error(`Request failed with status ${res.statusCode}: ${data}`));
+                        } else {
+                            resolve(result);
+                        }
+                    } catch (error) {
+                        reject(new Error(`Failed to parse response: ${error.message}`));
+                    }
+                });
             }).on('error', reject);
 
-            req.write(JSON.stringify(payload));
+            req.write(typeof payload === 'string' ? payload : JSON.stringify(payload));
             req.end();
         });
     }
 
-    async pollForMessages(chatId, app) {
-        const payload = { 
-            ...app, 
-            action: 'getChatMessages', 
-            chatId, 
-            decryptContent: true 
-        };
-        
-        return new Promise((resolve) => {
-            const interval = setInterval(() => {
-                this.makeRequest('https://chat.openkbs.com/', payload)
-                    .then(jsonString => {
-                        const messages = JSON.parse(jsonString)[0].data.messages;
-                        for (const message of messages) {
-                            if (message.role === 'system' && 
-                                /{"type"\s*:\s*"(JOB_COMPLETED|JOB_FAILED)".*?}/s.test(message.content)) {
-                                
-                                const result = JSON.parse(message.content)?.data?.find(item => 
-                                    item.type === 'JOB_COMPLETED' || item.type === 'JOB_FAILED'
-                                );
-                                clearInterval(interval);
-                                resolve(result);
-                                return;
-                            }
-                        }
-                    })
-                    .catch(console.error);
-            }, 1000);
+    // Raw request for binary data
+    async requestRaw(url, data, headers = {}, method = 'PUT') {
+        return new Promise((resolve, reject) => {
+            const { hostname, pathname, search } = new URL(url);
+            const req = https.request({
+                hostname,
+                path: pathname + (search || ''),
+                method,
+                headers
+            }, res => {
+                if (res.statusCode === 200 || res.statusCode === 204) {
+                    resolve();
+                } else {
+                    let responseData = '';
+                    res.on('data', chunk => responseData += chunk);
+                    res.on('end', () => reject(new Error(`Request failed with status ${res.statusCode}: ${responseData}`)));
+                }
+            }).on('error', reject);
+
+            req.write(data);
+            req.end();
         });
     }
 }

package/templates/src/Events/handler.js

@@ -13,7 +13,7 @@ export const backendHandler = async (event) => {
         return acc;
     }, []);
 
-    // Avoid unnecessary LLM reactions if job is finished
+    // IMPORTANT: Actions returning JOB_COMPLETED or JOB_FAILED stop agent execution and return final result
     const isJobFinished = /"JOB_COMPLETED"|"JOB_FAILED"/.test(lastMessage.content);
 
     const meta = {

package/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.51",
-  "releaseDate": "2025-08-01",
-  "releaseNotes": "OpenKBS CLI version 0.0.51"
+  "version": "0.0.53",
+  "releaseDate": "2025-09-25",
+  "releaseNotes": "OpenKBS CLI version 0.0.53"
 }