Remixai chat

apps/circuit-compiler/src/app/components/container.tsx

@@ -74,15 +74,17 @@ export function Container () {
           explain why the error occurred and how to fix it.
           `
         // @ts-ignore
-        await circuitApp.plugin.call('remixAI', 'error_explaining', message)
+        await circuitApp.plugin.call('remixAI' as any, 'chatPipe', 'error_explaining', message)
+        // await circuitApp.plugin.call('remixAI', 'error_explaining', message)
       } else {
         const message = `
           error message: ${error}
           full circom error: ${JSON.stringify(report, null, 2)}
           explain why the error occurred and how to fix it.
           `
         // @ts-ignore
-        await circuitApp.plugin.call('remixAI', 'error_explaining', message)
+        await circuitApp.plugin.call('remixAI' as any, 'chatPipe', 'error_explaining', message)
+        //await circuitApp.plugin.call('remixAI', 'error_explaining', message)
       }
     } else {
       const error = report.message
@@ -92,7 +94,8 @@ export function Container () {
       explain why the error occurred and how to fix it.
       `
       // @ts-ignore
-      await circuitApp.plugin.call('remixAI', 'error_explaining', message)
+      //await circuitApp.plugin.call('remixAI', 'error_explaining', message)
+      await circuitApp.plugin.call('remixAI' as any, 'chatPipe', 'error_explaining', message)
     }
   }
 

apps/remix-ide/src/app/plugins/remixAIPlugin.tsx

@@ -1,33 +1,38 @@
 import * as packageJson from '../../../../../package.json'
 import { ViewPlugin } from '@remixproject/engine-web'
 import { Plugin } from '@remixproject/engine';
-import { RemixAITab } from '@remix-ui/remix-ai'
-import React from 'react';
-import { ICompletions, IModel, RemoteInferencer, IRemoteModel } from '@remix/remix-ai-core';
+import { RemixAITab, ChatApi } from '@remix-ui/remix-ai'
+import React, { useCallback } from 'react';
+import { ICompletions, IModel, RemoteInferencer, IRemoteModel, IParams, GenerationParams, HandleStreamResponse } from '@remix/remix-ai-core';
+
+type chatRequestBufferT<T> = {
+  [key in keyof T]: T[key]
+}
 
 const profile = {
   name: 'remixAI',
   displayName: 'Remix AI',
   methods: ['code_generation', 'code_completion',
     "solidity_answer", "code_explaining",
     "code_insertion", "error_explaining",
-    "initialize"],
+    "initialize", 'chatPipe', 'ProcessChatRequestBuffer', 'isChatRequestPending'],
   events: [],
   icon: 'assets/img/remix-logo-blue.png',
   description: 'RemixAI provides AI services to Remix IDE.',
   kind: '',
-  // location: 'sidePanel',
+  location: 'sidePanel',
   documentation: 'https://remix-ide.readthedocs.io/en/latest/remixai.html',
   version: packageJson.version,
   maintainedBy: 'Remix'
 }
 
-export class RemixAIPlugin extends Plugin {
+export class RemixAIPlugin extends ViewPlugin {
   isOnDesktop:boolean = false
   aiIsActivated:boolean = false
   readonly remixDesktopPluginName = 'remixAID'
   remoteInferencer:RemoteInferencer = null
   isInferencing: boolean = false
+  chatRequestBuffer: chatRequestBufferT<any> = null
 
   constructor(inDesktop:boolean) {
     super(profile)
@@ -68,7 +73,6 @@ export class RemixAIPlugin extends Plugin {
       }
 
     } else {
-      // on browser
       this.remoteInferencer = new RemoteInferencer(remoteModel?.apiUrl, remoteModel?.completionUrl)
       this.remoteInferencer.event.on('onInference', () => {
         this.isInferencing = true
@@ -103,61 +107,52 @@ export class RemixAIPlugin extends Plugin {
     }
   }
 
-  async solidity_answer(prompt: string): Promise<any> {
+  async solidity_answer(prompt: string, params: IParams=GenerationParams): Promise<any> {
     if (this.isInferencing) {
       this.call('terminal', 'log', { type: 'aitypewriterwarning', value: "RemixAI is already busy!" })
       return
     }
 
-    this.call('terminal', 'log', { type: 'aitypewriterwarning', value: `\n\nWaiting for RemixAI answer...` })
-
     let result
     if (this.isOnDesktop) {
       result = await this.call(this.remixDesktopPluginName, 'solidity_answer', prompt)
     } else {
       result = await this.remoteInferencer.solidity_answer(prompt)
     }
-    if (result) this.call('terminal', 'log', { type: 'aitypewriterwarning', value: result })
-    // this.call('terminal', 'log', { type: 'aitypewriterwarning', value: "RemixAI Done" })
+    if (result && params.terminal_output) this.call('terminal', 'log', { type: 'aitypewriterwarning', value: result })
     return result
   }
 
-  async code_explaining(prompt: string): Promise<any> {
+  async code_explaining(prompt: string, context: string, params: IParams=GenerationParams): Promise<any> {
     if (this.isInferencing) {
       this.call('terminal', 'log', { type: 'aitypewriterwarning', value: "RemixAI is already busy!" })
       return
     }
-
-    this.call('terminal', 'log', { type: 'aitypewriterwarning', value: `\n\nWaiting for RemixAI answer...` })
-
+
     let result
     if (this.isOnDesktop) {
-      result = await this.call(this.remixDesktopPluginName, 'code_explaining', prompt)
+      result = await this.call(this.remixDesktopPluginName, 'code_explaining', prompt, context, params)
 
     } else {
-      result = await this.remoteInferencer.code_explaining(prompt)
+      result = await this.remoteInferencer.code_explaining(prompt, context, params)
     }
-    if (result) this.call('terminal', 'log', { type: 'aitypewriterwarning', value: result })
-    // this.call('terminal', 'log', { type: 'aitypewriterwarning', value: "RemixAI Done" })
+    if (result && params.terminal_output) this.call('terminal', 'log', { type: 'aitypewriterwarning', value: result })
     return result
   }
 
-  async error_explaining(prompt: string): Promise<any> {
+  async error_explaining(prompt: string, context: string="", params: IParams=GenerationParams): Promise<any> {
     if (this.isInferencing) {
       this.call('terminal', 'log', { type: 'aitypewriterwarning', value: "RemixAI is already busy!" })
       return
     }
 
-    this.call('terminal', 'log', { type: 'aitypewriterwarning', value: `\n\nWaiting for RemixAI answer...` })
-
     let result
     if (this.isOnDesktop) {
       result = await this.call(this.remixDesktopPluginName, 'error_explaining', prompt)
     } else {
-      result = await this.remoteInferencer.error_explaining(prompt)
+      result = await this.remoteInferencer.error_explaining(prompt, params)
     }
-    if (result) this.call('terminal', 'log', { type: 'aitypewriterwarning', value: result })
-    // this.call('terminal', 'log', { type: 'aitypewriterwarning', value: "RemixAI Done" })
+    if (result && params.terminal_output) this.call('terminal', 'log', { type: 'aitypewriterwarning', value: result })
     return result
   }
 
@@ -169,9 +164,46 @@ export class RemixAIPlugin extends Plugin {
     }
   }
 
-  // render() {
-  //   return (
-  //     <RemixAITab plugin={this}></RemixAITab>
-  //   )
-  // }
+  chatPipe(fn, prompt: string, context?: string, pipeMessage?: string){
+    if (this.chatRequestBuffer == null){
+      this.chatRequestBuffer = {
+        fn_name: fn,
+        prompt: prompt,
+        context: context
+      }
+      console.log('pipe message', pipeMessage)
+      if (pipeMessage) ChatApi.composer.send(pipeMessage)
+      else {
+        if      (fn === "code_explaining")  ChatApi.composer.send("Explain the current code")
+        else if (fn === "error_explaining") ChatApi.composer.send("Explain the error")
+        else if (fn === "solidity_answer")  ChatApi.composer.send("Answer the following question")
+        else console.log("chatRequestBuffer is not empty. First process the last request.")
+      }
+    }
+    else{
+      console.log("chatRequestBuffer is not empty. First process the last request.")
+    }
+  }
+
+
+  async ProcessChatRequestBuffer(params:IParams=GenerationParams){
+    if (this.chatRequestBuffer != null){
+      const result = this[this.chatRequestBuffer.fn_name](this.chatRequestBuffer.prompt, this.chatRequestBuffer.context, params)
+      this.chatRequestBuffer = null
+      return result
+    }
+    else{
+      console.log("chatRequestBuffer is empty.")
+      return ""
+    }
+  }
+  isChatRequestPending(){
+    return this.chatRequestBuffer != null
+  }
+
+  render() {
+    return (
+      <RemixAITab plugin={this}></RemixAITab>
+    )
+  }
 }

apps/remix-ide/src/app/tabs/locales/en/editor.json

@@ -25,8 +25,9 @@
   "editor.explainFunction": "Explain this function",
   "editor.explainFunctionSol": "Explain this code",
   "editor.explainFunction2": "Explain the function \"{name}\"",
-  "editor.explainFunctionByAI": "solidity code: {content}\n Explain the function {currentFunction}",
-  "editor.explainFunctionByAISol": "solidity code: {content}\n Explain the function {currentFunction}",
+  "editor.explainFunctionByAI": "```\n{content}\n```\nExplain the function {currentFunction}",
+  "editor.explainFunctionByAISol": "```\n{content}\n```\nExplain the function {currentFunction}",
+  "editor.ExplainPipeMessage": "```\n {content}\n```\nExplain the snipped above",
   "editor.executeFreeFunction": "Run a free function",
   "editor.executeFreeFunction2": "Run the free function \"{name}\"",
   "editor.toastText1": "This can only execute free function",

apps/remix-ide/src/remixAppManager.js

@@ -77,7 +77,6 @@ let requiredModules = [ // services + layout views + system views
   'doc-gen',
   'remix-templates',
   'remixAID',
-  'remixAI',
   'solhint',
   'dgit',
   'pinnedPanel',

apps/remixdesktop/src/lib/InferenceServerManager.ts

@@ -484,9 +484,9 @@ export class InferenceManager implements ICompletions {
       return
     }
     if (params.stream_result) {
-      return this._streamInferenceRequest('code_explaining', { code, context, ...params })
+      return this._streamInferenceRequest('code_explaining', { prompt: code, context, ...params })
     } else {
-      return this._makeInferenceRequest('code_explaining', { code, context, ...params }, AIRequestType.GENERAL)
+      return this._makeInferenceRequest('code_explaining', { prompt: code, context, ...params }, AIRequestType.GENERAL)
     }
   }
 

apps/vyper/src/app/utils/remix-client.tsx

@@ -72,7 +72,8 @@ export class RemixClient extends PluginClient<any, CustomRemixApi> {
         ${message}
         can you explain why this error occurred and how to fix it?
       `
-      await this.client.call('remixAI' as any, 'error_explaining', message)
+      // await this.client.call('remixAI' as any, 'error_explaining', message)
+      await this.client.call('remixAI' as any, 'chatPipe', 'error_explaining', message)
     } catch (err) {
       console.error('unable to askGpt')
       console.error(err)

libs/remix-ai-core/src/helpers/streamHandler.ts

@@ -0,0 +1,61 @@
+import { ChatHistory } from '../prompts/chat';
+import { JsonStreamParser} from '../types/types'
+
+export const HandleSimpleResponse = async (response, 
+    cb?: (streamText: string) => void) => {
+    let resultText = ''
+    const parser = new JsonStreamParser();
+
+    const chunk = parser.safeJsonParse<{ generatedText: string; isGenerating: boolean }>(response);
+    for (const parsedData of chunk) {
+        if (parsedData.isGenerating) {
+            resultText += parsedData.generatedText
+            cb(parsedData.generatedText)
+        } else {
+            resultText += parsedData.generatedText
+            cb(parsedData.generatedText)
+        }
+    }
+}
+
+export const HandleStreamResponse = async (streamResponse, 
+    cb?: (streamText: string) => void,
+    done_cb?: (result: string) => void) => {
+    try {
+        let resultText = ''
+        const parser = new JsonStreamParser();
+        const reader = streamResponse.body!.getReader();
+        const decoder = new TextDecoder();
+
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            try {
+                const chunk = parser.safeJsonParse<{ generatedText: string; isGenerating: boolean }>(decoder.decode(value, { stream: true }));
+                for (const parsedData of chunk) {
+                    if (parsedData.isGenerating) {
+                        resultText += parsedData.generatedText
+                        cb(parsedData.generatedText)
+                    } else {
+                        resultText += parsedData.generatedText
+                        cb(parsedData.generatedText)
+                    }
+                }
+            }
+            catch (error) {
+                console.error('Error parsing JSON:', error);
+            }
+        }
+        if (done_cb) {
+            done_cb(resultText)
+        }
+    }
+    catch (error) {
+        console.error('Error parsing JSON:', error);
+    }
+}
+
+export const UpdtateChatHistory = (userPromptprompt: string, AIAnswer: string) => {
+    ChatHistory.pushHistory(userPromptprompt, AIAnswer)
+}

libs/remix-ai-core/src/index.ts

@@ -17,4 +17,7 @@ export {
   getCompletionPrompt, getInsertionPrompt, IStreamResponse, buildSolgptPromt,
   RemoteInferencer, InsertionParams, CompletionParams, GenerationParams,
   ChatEntry, AIRequestType, RemoteBackendOPModel, ChatHistory, downloadLatestReleaseExecutable
-}
+}
+
+export * from './types/types'
+export * from './helpers/streamHandler'