Working now somewhat

1 files changed, 52 insertions, 31 deletions

diff --git a/src/client/views/nodes/ChatBox/Agent.ts b/src/client/views/nodes/ChatBox/Agent.ts
index 4c2838540..355acb19f 100644
--- a/src/client/views/nodes/ChatBox/Agent.ts
+++ b/src/client/views/nodes/ChatBox/Agent.ts
@@ -18,7 +18,7 @@ export class Agent {
     private summaries: string;
 
     constructor(private vectorstore: Vectorstore) {
-        this.client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+        this.client = new OpenAI({ apiKey: process.env.OPENAI_KEY, dangerouslyAllowBrowser: true });
         this.summaries = this.vectorstore ? this.vectorstore.getSummaries() : 'No documents available.';
         this.tools = {
             wikipedia: new WikipediaTool(),
@@ -40,7 +40,7 @@ export class Agent {
         return history;
     }
 
-    async askAgent(question: string, maxTurns: number = 5): Promise<string> {
+    async askAgent(question: string, maxTurns: number = 8): Promise<string> {
         console.log(`Starting query: ${question}`);
         this.messages.push({ role: 'user', content: question });
         const chatHistory = this.formatChatHistory();
@@ -51,6 +51,10 @@ export class Agent {
 
         this.interMessages.push({ role: 'assistant', content: `<query>${question}</query>` });
 
+        const parser = new XMLParser();
+        const builder = new XMLBuilder();
+        let currentAction: string | undefined;
+
         for (let i = 0; i < maxTurns; i++) {
             console.log(`Turn ${i + 1}/${maxTurns}`);
 
@@ -58,42 +62,58 @@ export class Agent {
             console.log(`Bot response: ${result}`);
             this.interMessages.push({ role: 'assistant', content: result });
 
+            let parsedResult;
             try {
-                const parser = new XMLParser();
-                const parsedResult = parser.parse(result);
-                const step = parsedResult[`step${i + 1}`];
-
-                if (step.thought) console.log(`Thought: ${step.thought}`);
-                if (step.action) {
-                    console.log(`Action: ${step.action}`);
-                    const action = step.action;
-                    const actionRules = new XMLBuilder().build({
-                        action_rules: this.tools[action].getActionRule(),
-                    });
-                    this.interMessages.push({ role: 'user', content: actionRules });
-                }
-                if (step.action_input) {
-                    const actionInput = new XMLBuilder().build({ action_input: step.action_input });
+                parsedResult = parser.parse(result);
+            } catch (error) {
+                console.log('Error: Invalid XML response from bot');
+                return '<error>Invalid response format.</error>';
+            }
+
+            const step = parsedResult[Object.keys(parsedResult)[0]];
+
+            for (const key in step) {
+                if (key === 'thought') {
+                    console.log(`Thought: ${step[key]}`);
+                } else if (key === 'action') {
+                    currentAction = step[key] as string;
+                    console.log(`Action: ${currentAction}`);
+                    if (this.tools[currentAction]) {
+                        const nextPrompt = [
+                            {
+                                type: 'text',
+                                text: builder.build({ action_rules: this.tools[currentAction].getActionRule() }),
+                            },
+                        ];
+                        this.interMessages.push({ role: 'assistant', content: nextPrompt });
+                        break;
+                    } else {
+                        console.log('Error: No valid action');
+                    }
+                } else if (key === 'action_input') {
+                    const actionInput = builder.build({ action_input: step[key] });
                     console.log(`Action input: ${actionInput}`);
-                    try {
-                        const observation = await this.processAction(step.action, step.action_input);
-                        const nextPrompt = [{ type: 'text', text: '<observation>' }, ...observation, { type: 'text', text: '</observation>' }];
-                        this.interMessages.push({ role: 'user', content: nextPrompt });
-                    } catch (e) {
-                        console.error(`Error processing action: ${e}`);
-                        return `<error>${e}</error>`;
+                    if (currentAction) {
+                        try {
+                            const observation = await this.processAction(currentAction, step[key]);
+                            const nextPrompt = [{ type: 'text', text: '<observation>' }, ...observation, { type: 'text', text: '</observation>' }];
+                            this.interMessages.push({ role: 'assistant', content: nextPrompt });
+                            break;
+                        } catch (error) {
+                            console.log(`Error processing action: ${error}`);
+                            return `<error>${error}</error>`;
+                        }
+                    } else {
+                        console.log('Error: Action input without a valid action');
+                        return '<error>Action input without a valid action</error>';
                     }
-                }
-                if (step.answer) {
+                } else if (key === 'answer') {
                     console.log('Answer found. Ending query.');
-                    const answerContent = new XMLBuilder().build({ answer: step.answer });
+                    const answerContent = builder.build({ answer: step[key] });
                     this.messages.push({ role: 'assistant', content: answerContent });
                     this.interMessages = [];
                     return answerContent;
                 }
-            } catch (e) {
-                console.error('Error: Invalid XML response from bot');
-                return '<error>Invalid response format.</error>';
             }
         }
 
@@ -102,8 +122,9 @@ export class Agent {
     }
 
     private async execute(): Promise<string> {
+        console.log('Messages: ' + this.interMessages);
         const completion = await this.client.chat.completions.create({
-            model: 'gpt-4',
+            model: 'gpt-4o',
             messages: this.interMessages as ChatCompletionMessageParam[],
             temperature: 0,
         });